logixlysia 5.3.0 → 6.0.0

package/src/logger/index.ts

@@ -0,0 +1,126 @@
+import pino from 'pino'
+import type {
+  Logger,
+  LogLevel,
+  Options,
+  Pino,
+  RequestInfo,
+  StoreData
+} from '../interfaces'
+import { logToTransports } from '../output'
+import { logToFile } from '../output/file'
+import { formatLine } from './create-logger'
+import { handleHttpError } from './handle-http-error'
+
+export const createLogger = (options: Options = {}): Logger => {
+  const config = options.config
+
+  const pinoConfig = config?.pino
+  const { prettyPrint, ...pinoOptions } = pinoConfig ?? {}
+
+  const shouldPrettyPrint =
+    prettyPrint === true && pinoOptions.transport === undefined
+
+  const transport = shouldPrettyPrint
+    ? pino.transport({
+        target: 'pino-pretty',
+        options: {
+          colorize: process.stdout?.isTTY === true,
+          translateTime: config?.timestamp?.translateTime,
+          messageKey: pinoOptions.messageKey,
+          errorKey: pinoOptions.errorKey
+        }
+      })
+    : pinoOptions.transport
+
+  const pinoLogger: Pino = pino({
+    ...pinoOptions,
+    level: pinoOptions.level ?? 'info',
+    messageKey: pinoOptions.messageKey,
+    errorKey: pinoOptions.errorKey,
+    transport
+  })
+
+  const log = (
+    level: LogLevel,
+    request: RequestInfo,
+    data: Record<string, unknown>,
+    store: StoreData
+  ): void => {
+    logToTransports({ level, request, data, store, options })
+
+    const useTransportsOnly = config?.useTransportsOnly === true
+    const disableInternalLogger = config?.disableInternalLogger === true
+    const disableFileLogging = config?.disableFileLogging === true
+
+    if (!(useTransportsOnly || disableFileLogging)) {
+      const filePath = config?.logFilePath
+      if (filePath) {
+        logToFile({ filePath, level, request, data, store, options }).catch(
+          () => {
+            // Ignore errors
+          }
+        )
+      }
+    }
+
+    if (useTransportsOnly || disableInternalLogger) {
+      return
+    }
+
+    const message = formatLine({ level, request, data, store, options })
+
+    switch (level) {
+      case 'DEBUG': {
+        console.debug(message)
+        break
+      }
+      case 'INFO': {
+        console.info(message)
+        break
+      }
+      case 'WARNING': {
+        console.warn(message)
+        break
+      }
+      case 'ERROR': {
+        console.error(message)
+        break
+      }
+      default: {
+        console.log(message)
+        break
+      }
+    }
+  }
+
+  const logWithContext = (
+    level: LogLevel,
+    request: RequestInfo,
+    message: string,
+    context?: Record<string, unknown>
+  ): void => {
+    const store: StoreData = { beforeTime: process.hrtime.bigint() }
+    log(level, request, { message, context }, store)
+  }
+
+  return {
+    pino: pinoLogger,
+    log,
+    handleHttpError: (request, error, store) => {
+      handleHttpError(request, error, store, options)
+    },
+    debug: (request, message, context) => {
+      logWithContext('DEBUG', request, message, context)
+    },
+    info: (request, message, context) => {
+      logWithContext('INFO', request, message, context)
+    },
+    warn: (request, message, context) => {
+      logWithContext('WARNING', request, message, context)
+    },
+    error: (request, message, context) => {
+      logWithContext('ERROR', request, message, context)
+    }
+  }
+}

package/src/output/file.ts

@@ -0,0 +1,85 @@
+import { appendFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import type { LogLevel, Options, RequestInfo, StoreData } from '../interfaces'
+import { ensureDir } from './fs'
+import { performRotation, shouldRotate } from './rotation-manager'
+
+type LogToFileInput = {
+  filePath: string
+  level: LogLevel
+  request: RequestInfo
+  data: Record<string, unknown>
+  store: StoreData
+  options: Options
+}
+
+export const logToFile = async (
+  ...args:
+    | [LogToFileInput]
+    | [
+        string,
+        LogLevel,
+        RequestInfo,
+        Record<string, unknown>,
+        StoreData,
+        Options
+      ]
+): Promise<void> => {
+  const input: LogToFileInput =
+    typeof args[0] === 'string'
+      ? (() => {
+          const [
+            filePathArg,
+            levelArg,
+            requestArg,
+            dataArg,
+            storeArg,
+            optionsArg
+          ] = args as [
+            string,
+            LogLevel,
+            RequestInfo,
+            Record<string, unknown>,
+            StoreData,
+            Options
+          ]
+          return {
+            filePath: filePathArg,
+            level: levelArg,
+            request: requestArg,
+            data: dataArg,
+            store: storeArg,
+            options: optionsArg
+          }
+        })()
+      : args[0]
+
+  const { filePath, level, request, data, store, options } = input
+  const config = options.config
+  const useTransportsOnly = config?.useTransportsOnly === true
+  const disableFileLogging = config?.disableFileLogging === true
+  if (useTransportsOnly || disableFileLogging) {
+    return
+  }
+
+  const message = typeof data.message === 'string' ? data.message : ''
+  const durationMs =
+    store.beforeTime === BigInt(0)
+      ? 0
+      : Number(process.hrtime.bigint() - store.beforeTime) / 1_000_000
+
+  const line = `${level} ${durationMs.toFixed(2)}ms ${request.method} ${new URL(request.url).pathname} ${message}\n`
+
+  await ensureDir(dirname(filePath))
+  await appendFile(filePath, line, { encoding: 'utf-8' })
+
+  const rotation = config?.logRotation
+  if (!rotation) {
+    return
+  }
+
+  const should = await shouldRotate(filePath, rotation)
+  if (should) {
+    await performRotation(filePath, rotation)
+  }
+}

package/src/output/fs.ts

@@ -0,0 +1,5 @@
+import { promises as fs } from 'node:fs'
+
+export const ensureDir = async (dirPath: string): Promise<void> => {
+  await fs.mkdir(dirPath, { recursive: true })
+}

package/src/output/index.ts

@@ -0,0 +1,58 @@
+import type { LogLevel, Options, RequestInfo, StoreData } from '../interfaces'
+
+type LogToTransportsInput = {
+  level: LogLevel
+  request: RequestInfo
+  data: Record<string, unknown>
+  store: StoreData
+  options: Options
+}
+
+export const logToTransports = (
+  ...args:
+    | [LogToTransportsInput]
+    | [LogLevel, RequestInfo, Record<string, unknown>, StoreData, Options]
+): void => {
+  const input: LogToTransportsInput =
+    typeof args[0] === 'string'
+      ? {
+          level: args[0],
+          request: args[1],
+          data: args[2],
+          store: args[3],
+          options: args[4]
+        }
+      : args[0]
+
+  const { level, request, data, store, options } = input
+  const transports = options.config?.transports ?? []
+  if (transports.length === 0) {
+    return
+  }
+
+  const message = typeof data.message === 'string' ? data.message : ''
+  const meta: Record<string, unknown> = {
+    request: {
+      method: request.method,
+      url: request.url
+    },
+    ...data,
+    beforeTime: store.beforeTime
+  }
+
+  for (const transport of transports) {
+    try {
+      const result = transport.log(level, message, meta)
+      if (
+        result &&
+        typeof (result as { catch?: unknown }).catch === 'function'
+      ) {
+        ;(result as Promise<void>).catch(() => {
+          // Ignore errors
+        })
+      }
+    } catch {
+      // Transport failures must never crash application logging.
+    }
+  }
+}

package/src/output/rotation-manager.ts

@@ -0,0 +1,122 @@
+import { promises as fs } from 'node:fs'
+import { promisify } from 'node:util'
+import { gzip } from 'node:zlib'
+import type { LogRotationConfig } from '../interfaces'
+import {
+  getRotatedFiles,
+  parseRetention,
+  parseSize,
+  shouldRotateBySize
+} from '../utils/rotation'
+
+const gzipAsync = promisify(gzip)
+
+const pad2 = (value: number): string => String(value).padStart(2, '0')
+
+export const getRotatedFileName = (filePath: string, date: Date): string => {
+  const yyyy = date.getFullYear()
+  const mm = pad2(date.getMonth() + 1)
+  const dd = pad2(date.getDate())
+  const HH = pad2(date.getHours())
+  const MM = pad2(date.getMinutes())
+  const ss = pad2(date.getSeconds())
+  return `${filePath}.${yyyy}-${mm}-${dd}-${HH}-${MM}-${ss}`
+}
+
+export const rotateFile = async (filePath: string): Promise<string> => {
+  try {
+    const stat = await fs.stat(filePath)
+    if (stat.size === 0) {
+      return ''
+    }
+  } catch {
+    return ''
+  }
+
+  const rotated = getRotatedFileName(filePath, new Date())
+  await fs.rename(filePath, rotated)
+  return rotated
+}
+
+export const compressFile = async (filePath: string): Promise<void> => {
+  const content = await fs.readFile(filePath)
+  const compressed = await gzipAsync(content)
+  await fs.writeFile(`${filePath}.gz`, compressed)
+  await fs.rm(filePath, { force: true })
+}
+
+export const shouldRotate = async (
+  filePath: string,
+  config: LogRotationConfig
+): Promise<boolean> => {
+  if (config.maxSize === undefined) {
+    return false
+  }
+  const maxSize = parseSize(config.maxSize)
+  return await shouldRotateBySize(filePath, maxSize)
+}
+
+const cleanupByCount = async (
+  filePath: string,
+  maxFiles: number
+): Promise<void> => {
+  const rotated = await getRotatedFiles(filePath)
+  if (rotated.length <= maxFiles) {
+    return
+  }
+
+  const stats = await Promise.all(
+    rotated.map(async p => ({ path: p, stat: await fs.stat(p) }))
+  )
+
+  stats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+  const toDelete = stats.slice(maxFiles)
+  await Promise.all(toDelete.map(({ path }) => fs.rm(path, { force: true })))
+}
+
+const cleanupByTime = async (
+  filePath: string,
+  maxAgeMs: number
+): Promise<void> => {
+  const rotated = await getRotatedFiles(filePath)
+  if (rotated.length === 0) {
+    return
+  }
+
+  const now = Date.now()
+  const stats = await Promise.all(
+    rotated.map(async p => ({ path: p, stat: await fs.stat(p) }))
+  )
+
+  const toDelete = stats.filter(({ stat }) => now - stat.mtimeMs > maxAgeMs)
+  await Promise.all(toDelete.map(({ path }) => fs.rm(path, { force: true })))
+}
+
+export const performRotation = async (
+  filePath: string,
+  config: LogRotationConfig
+): Promise<void> => {
+  const rotated = await rotateFile(filePath)
+  if (!rotated) {
+    return
+  }
+
+  const shouldCompress = config.compress === true
+  if (shouldCompress) {
+    const algo = config.compression ?? 'gzip'
+    if (algo === 'gzip') {
+      await compressFile(rotated)
+    }
+  }
+
+  if (config.maxFiles !== undefined) {
+    const retention = parseRetention(config.maxFiles)
+    if (retention.type === 'count') {
+      await cleanupByCount(filePath, retention.value)
+    } else {
+      await cleanupByTime(filePath, retention.value)
+    }
+  }
+
+  // Optional interval-based rotation cleanup (create interval directories / naming) is not required by tests.
+}

package/src/utils/error.ts

@@ -0,0 +1,15 @@
+export const parseError = (error: unknown): string => {
+  let message = 'An error occurred'
+
+  if (error instanceof Error) {
+    message = error.message
+  } else if (error && typeof error === 'object' && 'message' in error) {
+    message = error.message as string
+  } else {
+    message = String(error)
+  }
+
+  console.error(`Parsing error: ${message}`)
+
+  return message
+}

package/src/utils/rotation.ts

@@ -0,0 +1,91 @@
+import { promises as fs } from 'node:fs'
+import { basename, dirname } from 'node:path'
+
+const SIZE_REGEX = /^(\d+(?:\.\d+)?)(k|kb|m|mb|g|gb)$/i
+const INTERVAL_REGEX = /^(\d+)(h|d|w)$/i
+const ROTATED_REGEX = /\.(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2})(?:\.gz)?$/
+
+export const parseSize = (value: number | string): number => {
+  if (typeof value === 'number') {
+    return value
+  }
+
+  const trimmed = value.trim()
+  const asNumber = Number(trimmed)
+  if (Number.isFinite(asNumber)) {
+    return asNumber
+  }
+
+  const match = trimmed.match(SIZE_REGEX)
+  if (!match) {
+    throw new Error(`Invalid size format: ${value}`)
+  }
+
+  const amount = Number(match[1])
+  const unit = match[2].toLowerCase()
+
+  let base = 1024
+  if (unit.startsWith('m')) {
+    base = 1024 * 1024
+  } else if (unit.startsWith('g')) {
+    base = 1024 * 1024 * 1024
+  }
+
+  return Math.floor(amount * base)
+}
+
+export const parseInterval = (value: string): number => {
+  const match = value.trim().match(INTERVAL_REGEX)
+  if (!match) {
+    throw new Error(`Invalid interval format: ${value}`)
+  }
+
+  const amount = Number(match[1])
+  const unit = match[2].toLowerCase()
+
+  let ms = 60 * 60 * 1000
+  if (unit === 'd') {
+    ms = 24 * 60 * 60 * 1000
+  } else if (unit === 'w') {
+    ms = 7 * 24 * 60 * 60 * 1000
+  }
+
+  return amount * ms
+}
+
+export const parseRetention = (
+  value: number | string
+): { type: 'count' | 'time'; value: number } => {
+  if (typeof value === 'number') {
+    return { type: 'count', value }
+  }
+  return { type: 'time', value: parseInterval(value) }
+}
+
+export const shouldRotateBySize = async (
+  filePath: string,
+  maxSizeBytes: number
+): Promise<boolean> => {
+  try {
+    const stat = await fs.stat(filePath)
+    return stat.size > maxSizeBytes
+  } catch {
+    return false
+  }
+}
+
+export const getRotatedFiles = async (filePath: string): Promise<string[]> => {
+  const dir = dirname(filePath)
+  const base = basename(filePath)
+
+  let entries: string[]
+  try {
+    entries = await fs.readdir(dir)
+  } catch {
+    return []
+  }
+
+  return entries
+    .filter(name => name.startsWith(`${base}.`) && ROTATED_REGEX.test(name))
+    .map(name => `${dir}/${name}`)
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 PunGrumpy
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,57 +0,0 @@
-<div align="center">
-  <h1><code>🦊</code> Logixlysia</h1>
-  <strong>Logixlysia is a logging library for ElysiaJS</strong>
-  <img src="./website/app/opengraph-image.png" alt="Logixlysia" width="100%" height="auto" />
-</div>
-
-## `📩` Installation
-
-```bash
-bun add logixlysia
-```
-
-## `📝` Usage
-
-```ts
-import { Elysia } from 'elysia'
-import logixlysia from 'logixlysia'
-
-const app = new Elysia({
-  name: 'Logixlysia Example'
-}).use(
-  logixlysia({
-    config: {
-      showStartupMessage: true,
-      startupMessageFormat: 'simple',
-      timestamp: {
-        translateTime: 'yyyy-mm-dd HH:MM:ss'
-      },
-      ip: true,
-      logFilePath: './logs/example.log',
-      logRotation: {
-        maxSize: '10m',
-        interval: '1d',
-        maxFiles: '7d',
-        compress: true
-      },
-      customLogFormat:
-        '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip} {epoch}',
-      logFilter: {
-        level: ['ERROR', 'WARNING'],
-        status: [500, 404],
-        method: 'GET'
-      }
-    }
-  })
-)
-
-app.listen(3000)
-```
-
-## `📚` Documentation
-
-Check out the [website](https://logixlysia.vercel.app) for more detailed documentation and examples.
-
-## `📄` License
-
-Licensed under the [MIT License](LICENSE).