@likec4/log 1.21.1 → 1.22.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/log",
   "license": "MIT",
-  "version": "1.21.1",
+  "version": "1.22.1",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -18,23 +18,10 @@
   "exports": {
     ".": {
       "sources": "./src/index.ts",
-      "node": {
+      "default": {
         "types": "./dist/index.d.ts",
         "import": "./dist/index.mjs",
         "require": "./dist/index.cjs"
-      },
-      "default": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/browser.mjs",
-        "require": "./dist/browser.cjs"
-      }
-    },
-    "./browser": {
-      "sources": "./src/browser.ts",
-      "default": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/browser.mjs",
-        "require": "./dist/browser.cjs"
       }
     }
   },
@@ -46,9 +33,12 @@
     "typecheck": "tsc --noEmit",
     "build": "unbuild"
   },
+  "dependencies": {
+    "@logtape/logtape": "^0.8.2"
+  },
   "devDependencies": {
-    "@likec4/tsconfig": "1.21.1",
-    "@types/node": "^20.17.7",
+    "@likec4/tsconfig": "1.22.1",
+    "@types/node": "^20.17.17",
     "consola": "^3.4.0",
     "merge-error-cause": "^5.0.0",
     "safe-stringify": "^1.1.1",

package/src/formatters.ts

@@ -0,0 +1,201 @@
+import {
+  type AnsiColorFormatterOptions,
+  type ConsoleSinkOptions,
+  type FormattedValues,
+  type LogLevel,
+  type LogRecord,
+  type Sink,
+  type TextFormatter,
+  type TextFormatterOptions,
+  getAnsiColorFormatter as getLogtapeAnsiColorFormatter,
+  getConsoleSink as getLogtapeConsoleSink,
+  getTextFormatter as getLogtapeTextFormatter,
+} from '@logtape/logtape'
+import mergeErrorCause from 'merge-error-cause'
+import wrapErrorMessage from 'wrap-error-message'
+import { ident, parseStack } from './utils'
+
+// export function formatProperties(properties: Record<string, unknown>): {
+//   properties: Record<string, unknown>
+//   output?: string
+//   error?: never
+// } | {
+//   properties: Record<string, unknown>
+//   output: string
+//   error?: {
+//     message: string
+//     name: string
+//     stack?: string
+//   }
+// } {
+//   let error: {
+//     message: string
+//     name: string
+//     stack?: string
+//   } | undefined
+//   let totalProps = 0
+//   const formattedProperties = {} as Record<string, unknown>
+//   for (const [key, value] of Object.entries(properties)) {
+//     if (value instanceof Error) {
+//       const mergedErr = mergeErrorCause(value)
+//       const stack = mergedErr.stack ? parseStack(mergedErr.stack) : undefined
+//       const formattedError = {
+//         message: mergedErr.message,
+//         name: mergedErr.name,
+//         ...stack && { stack: stack.join('\n') },
+//       }
+//       error ??= formattedError
+//       formattedProperties[key] = formattedError
+//     } else {
+//       formattedProperties[key] = value
+//     }
+//     totalProps++
+//   }
+//   if (totalProps === 0) {
+//     return {
+//       properties: formattedProperties,
+//     }
+//   }
+//   if (error) {
+//     return {
+//       error: error,
+//       output: error.stack ? error.message + '\n' + ident(error.stack.slice(1)) : error.message,
+//       properties: formattedProperties,
+//     }
+//   }
+//   return {
+//     ...(error && { error: error }),
+//     output: safeStringify(formattedProperties, { indentation: '\t' }),
+//     properties: formattedProperties,
+//   }
+// }
+
+function gerErrorFromLogRecord(record: LogRecord): Error | null {
+  const errors = Object
+    .values(record.properties)
+    .filter((v) => v instanceof Error)
+    .map(err => {
+      const mergedErr = mergeErrorCause(err)
+      if (mergedErr.stack) {
+        mergedErr.stack = parseStack(mergedErr.stack).join('\n')
+      }
+      return mergedErr
+    })
+  if (errors.length === 0) {
+    return null
+  }
+  return errors.length === 1 ? errors[0]! : new AggregateError(errors)
+}
+
+export function errorFromLogRecord(record: LogRecord): Error | null {
+  const error = gerErrorFromLogRecord(record)
+  if (error && typeof record.rawMessage === 'string') {
+    return wrapErrorMessage(error, record.rawMessage + '\n')
+  }
+  return error
+}
+
+export function appendErrorToMessage(values: FormattedValues, color?: boolean): FormattedValues {
+  const error = gerErrorFromLogRecord(values.record)
+  if (error) {
+    let errorMessge = error.message
+    if (error.stack) {
+      errorMessge = errorMessge + '\n' + ident(error.stack.split('\n').slice(1))
+    }
+    if (color) {
+      errorMessge = `${ansiColors.red}${errorMessge}${RESET}`
+    }
+    return {
+      ...values,
+      message: values.message + '\n' + ident(errorMessge),
+    }
+  }
+  return values
+}
+
+// export function formatRecord(values: FormattedValues): FormattedValues {
+//   const props = formatProperties(values.record.properties)
+//   if (props.output) {
+//     props.output = ' \n' + ident(props.output)
+//     return {
+//       ...values,
+//       record: {
+//         ...values.record,
+//         properties: props.properties,
+//       },
+//       message: `${values.message}${props.output}`,
+//     }
+//   }
+//   return values
+// }
+
+const levelAbbreviations: Record<LogLevel, string> = {
+  'debug': 'DEBUG',
+  'info': 'INFO ',
+  'warning': 'WARN ',
+  'error': 'ERROR',
+  'fatal': 'FATAL',
+}
+
+export function getMessageOnlyFormatter(): TextFormatter {
+  return getTextFormatter({
+    format: ({ message }): string => {
+      return message
+    },
+  })
+}
+
+const level = (l: LogLevel): string => levelAbbreviations[l]
+
+export function getTextFormatter(options?: TextFormatterOptions): TextFormatter {
+  const _format = options?.format ?? (({ timestamp, level, category, message }: FormattedValues): string => {
+    return `${timestamp} ${level} ${category} ${message}`
+  })
+  // const format = options?.format
+  return getLogtapeTextFormatter({
+    timestamp: 'time',
+    level,
+    category: '.',
+    ...options,
+    format: (values) => {
+      return _format(appendErrorToMessage(values))
+    },
+  })
+}
+
+const RESET = '\x1b[0m'
+
+const ansiColors = {
+  // black: "\x1b[30m",
+  red: '\x1b[31m',
+  // green: "\x1b[32m",
+  // yellow: "\x1b[33m",
+  // blue: "\x1b[34m",
+  // magenta: "\x1b[35m",
+  // cyan: "\x1b[36m",
+  // white: "\x1b[37m",
+} as const
+
+export function getAnsiColorFormatter(options?: AnsiColorFormatterOptions): TextFormatter {
+  const _format = options?.format ?? (({ timestamp, level, category, message }: FormattedValues): string => {
+    return `${timestamp} ${level} ${category} ${message}`
+  })
+  return getLogtapeAnsiColorFormatter({
+    timestamp: 'time',
+    level,
+    categoryStyle: 'bold',
+    categoryColor: 'cyan',
+    category: '.',
+    ...options,
+    format: (values) => {
+      return _format(appendErrorToMessage(values, true))
+    },
+  })
+}
+
+export function getConsoleSink(options?: ConsoleSinkOptions): Sink {
+  return getLogtapeConsoleSink({
+    formatter: getAnsiColorFormatter(),
+    ...options,
+  })
+}

package/src/index.ts

@@ -1,36 +1,88 @@
-import { createConsola } from 'consola'
-import { type LogObject, LogLevels } from 'consola/core'
-import { sep } from 'node:path'
-import { cwd } from 'node:process'
-import { type FormattedLogObject, formattedLogObj } from './format'
-
-export type * from 'consola/core'
-export type { FormattedLogObject }
-
-function parseStack(stack: string): string[] {
-  const currentDir = cwd() + sep
-  const lines = stack.split('\n').map((l) => l.trim().replace('file://', '').replace(currentDir, ''))
-  return lines
+import {
+  type Config,
+  configure as configureLogtape,
+  getLogger,
+} from '@logtape/logtape'
+import { getConsoleSink } from './formatters'
+
+export type {
+  Filter,
+  Logger,
+  LogLevel,
+  LogRecord,
+  Sink,
+  TextFormatter,
+} from '@logtape/logtape'
+
+export {
+  errorFromLogRecord,
+  // formatProperties,
+  // formatRecord,
+  getAnsiColorFormatter,
+  getConsoleSink,
+  getMessageOnlyFormatter,
+  getTextFormatter,
+} from './formatters'
+
+export {
+  withFilter,
+} from '@logtape/logtape'
+
+export {
+  logger as consola,
+  logger as rootLogger,
+}
+
+export {
+  loggable,
+} from './utils'
+
+export const logger = getLogger('likec4')
+
+/**
+ * Get a child logger with the given subcategory.
+ *
+ * @param subcategory The subcategory.
+ * @returns The child logger.
+ */
+export function createLogger(subcategory: string | readonly [string] | readonly [string, ...string[]]) {
+  return logger.getChild(subcategory)
 }
 
-export function formatLogObj(logObj: LogObject): FormattedLogObject {
-  return formattedLogObj(logObj, parseStack)
+let configureWasCalled = false
+
+export async function configureLogger<TSinkId extends string, TFilterId extends string>(
+  config?: Config<TSinkId, TFilterId>,
+) {
+  try {
+    configureWasCalled = true
+    const sinks = config?.sinks ?? {}
+    await configureLogtape<any, any>({
+      ...config,
+      sinks: {
+        ...sinks,
+        // @ts-expect-error console is not a valid sink id
+        console: sinks['console'] ?? getConsoleSink(),
+      },
+      loggers: [
+        { category: ['logtape', 'meta'], sinks: ['console' as any], lowestLevel: 'warning' },
+        ...(config?.loggers ?? [
+          {
+            category: 'likec4',
+            sinks: ['console' as any],
+            lowestLevel: 'debug',
+          },
+        ]),
+      ],
+    })
+  } catch (e) {
+    console.error(e)
+  }
 }
 
-const level = LogLevels.debug
-
-const consola = createConsola({
-  level,
-  defaults: {
-    level,
-  },
-  throttle: 2,
-  throttleMin: 500,
-  formatOptions: {
-    colors: true,
-    compact: false,
-    date: false,
-  },
-})
-
-export { consola, consola as logger, consola as rootLogger, LogLevels }
+export function ensureLoggerIsConfigured() {
+  if (!configureWasCalled) {
+    configureLogger()
+    console.warn('logger automatically configured with default settings')
+  }
+}

package/src/utils.ts

@@ -0,0 +1,37 @@
+import mergeErrorCause from 'merge-error-cause'
+import safeStringify from 'safe-stringify'
+
+export const parseStack = (stack: string): string[] => {
+  const lines = stack
+    .split('\n')
+    .map((l) => {
+      let replaced = l.trim()
+        .replace('file://', '')
+      // // Remove c:\Users\<user>... -> @vscode...
+      // .replace(/[A-Za-z]:\\Users\\[^\\]+\\/g, '@vscode\\')
+      // // Remove /Users/<user>/... -> @vscode/...
+      // .replace(/\/Users\/[^/]+\//g, '@vscode/')
+      return replaced
+    })
+  return lines
+}
+
+export function ident(value: string | string[], identation = 2): string {
+  value = Array.isArray(value) ? value : value.split('\n')
+  return value.map((l) => `${' '.repeat(identation)}${l}`).join('\n')
+}
+
+export function loggable(error: unknown): string {
+  if (typeof error === 'string') {
+    return error
+  }
+  if (error instanceof Error) {
+    const mergedErr = mergeErrorCause(error)
+    if (mergedErr.stack) {
+      const stack = parseStack(mergedErr.stack)
+      return mergedErr.message + '\n' + ident(stack.slice(1))
+    }
+    return mergedErr.message
+  }
+  return safeStringify(error)
+}