logixlysia 3.5.0 → 3.6.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [3.6.1](https://github.com/PunGrumpy/logixlysia/compare/v3.6.0...v3.6.1) (2024-08-21)
+
+
+### Performance Improvements
+
+* **logger:** improve performance and fix TypeScript errors ([d3ed751](https://github.com/PunGrumpy/logixlysia/commit/d3ed751041443b9bd2ce53350994e1443df40971))
+
+## [3.6.0](https://github.com/PunGrumpy/logixlysia/compare/v3.5.0...v3.6.0) (2024-07-24)
+
+
+### Features
+
+* **custom-log:** add unix epoch timestamp option on `customLogFormat` configuration ([58d3e5b](https://github.com/PunGrumpy/logixlysia/commit/58d3e5b89bfef86aed1f5daa70d9a39982750073)), closes [#56](https://github.com/PunGrumpy/logixlysia/issues/56)
+* **transports:** add custom tranporter support for flexible logging ([69e1b89](https://github.com/PunGrumpy/logixlysia/commit/69e1b8991d323d8463fb81cf5bf1b441f678318b)), closes [#51](https://github.com/PunGrumpy/logixlysia/issues/51)
+
 ## [3.5.0](https://github.com/PunGrumpy/logixlysia/compare/v3.4.0...v3.5.0) (2024-07-11)
 
 

package/README.md

@@ -25,7 +25,7 @@ const app = new Elysia({
       ip: true,
       logFilePath: './logs/example.log',
       customLogFormat:
-        '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}',
+        '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip} {epoch}',
       logFilter: {
         level: ['ERROR', 'WARNING'],
         status: [500, 404],
@@ -38,6 +38,9 @@ const app = new Elysia({
 app.listen(3000)
 ```
 
+> [!NOTE]
+> You can discover more about example in the [example](example) directory.
+
 ## `📚` Documentation
 
 ### Options
@@ -50,6 +53,20 @@ app.listen(3000)
 | `logFilter`        | `object`  | Filter the logs based on the level, method, and status                | `null`                                                                    |
 | `logFilePath`      | `string`  | Path to the log file                                                  | `./logs/elysia.log`                                                       |
 
+### Custom Log Message
+
+| Placeholder  | Description                                                                 |
+| ------------ | --------------------------------------------------------------------------- |
+| `{now}`      | Current date and time in `YYYY-MM-DD HH:mm:ss` format                       |
+| `{level}`    | Log level (`INFO`, `WARNING`, `ERROR`)                                      |
+| `{duration}` | Request duration in milliseconds                                            |
+| `{method}`   | Request method (`GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`) |
+| `{pathname}` | Request pathname                                                            |
+| `{status}`   | Response status code                                                        |
+| `{message}`  | Custom message                                                              |
+| `{ip}`       | Incoming IP address                                                         |
+| `{epoch}`    | Current date and time in Unix epoch format (seconds since January 1, 1970   |
+
 ## `📄` License
 
 Licensed under the [MIT License](LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "3.5.0",
+  "version": "3.6.1",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,10 +15,10 @@
   },
   "license": "MIT",
   "scripts": {
-    "lint": "eslint ..",
-    "lint:fix": "eslint .. --fix",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "test": "bun test --timeout 5000 --coverage",
-    "test:ci": "bun test --timeout 5000 --coverage",
+    "test:ci": "bun test --timeout 5000 --coverage --coverage-reporter=lcov",
     "publish": "npm publish",
     "dev": "bun run --watch example/basic.ts",
     "prepare": "husky",
@@ -71,25 +71,26 @@
   ],
   "dependencies": {
     "chalk": "^5.3.0",
-    "elysia": "^1.0.24"
+    "elysia": "^1.1.4"
   },
   "devDependencies": {
-    "@elysiajs/eden": "^1.0.14",
-    "@eslint/js": "^9.5.0",
+    "@elysiajs/eden": "^1.1.1",
+    "@eslint/js": "^9.8.0",
     "@trunkio/launcher": "^1.3.1",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
-    "bun-types": "^1.1.13",
+    "@typescript-eslint/eslint-plugin": "^8.0.1",
+    "@typescript-eslint/parser": "^8.0.1",
+    "bun-types": "^1.1.20",
     "commitizen": "^4.3.0",
     "cz-conventional-changelog": "^3.3.0",
     "eslint": "9.x",
-    "eslint-plugin-simple-import-sort": "^12.1.0",
-    "husky": "^9.0.11",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "globals": "^15.9.0",
+    "husky": "^9.1.1",
     "lint-staged": "^15.2.7",
-    "prettier": "^3.3.2",
-    "typescript-eslint": "^7.13.1"
+    "prettier": "^3.3.3",
+    "typescript-eslint": "^8.0.1"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.2.2"
   }
 }

package/src/index.ts

@@ -1,9 +1,9 @@
 import { Server } from 'bun'
 import Elysia from 'elysia'
 
-import { createLogger, handleHttpError } from './logger'
-import { HttpError, Options } from './types'
-import startServer from './utils/start'
+import { createLogger, handleHttpError } from '~/logger'
+import { HttpError, Options } from '~/types'
+import startServer from '~/utils/start'
 
 /**
  * Creates a logger plugin for ElysiaJS.
@@ -41,3 +41,6 @@ export default function logixlysia(options?: Options): Elysia {
       )
     })
 }
+
+export { createLogger } from '~/logger'
+export { handleHttpError } from '~/logger'

package/src/logger/buildLogMessage.ts

@@ -1,12 +1,22 @@
 import chalk from 'chalk'
 
-import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
+import {
+  LogComponents,
+  LogData,
+  LogLevel,
+  Options,
+  RequestInfo,
+  StoreData
+} from '~/types'
 import durationString from '~/utils/duration'
 import logString from '~/utils/log'
 import methodString from '~/utils/method'
 import pathString from '~/utils/path'
 import statusString from '~/utils/status'
 
+const defaultLogFormat =
+  '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
+
 /**
  * Builds a log message.
  *
@@ -26,31 +36,30 @@ export function buildLogMessage(
   options?: Options,
   useColors: boolean = true
 ): string {
-  const nowStr = useColors
-    ? chalk.bgYellow(chalk.black(new Date().toLocaleString()))
-    : new Date().toLocaleString()
-  const levelStr = logString(level, useColors)
-  const durationStr = durationString(store.beforeTime, useColors)
-  const methodStr = methodString(request.method, useColors)
-  const pathnameStr = pathString(request)
-  const statusStr = statusString(data.status || 200, useColors)
-  const messageStr = data.message || ''
-  const ipStr =
-    options?.config?.ip && request.headers.get('x-forwarded-for')
-      ? `IP: ${request.headers.get('x-forwarded-for')}`
-      : ''
+  const now = new Date()
+  const components: LogComponents = {
+    now: useColors
+      ? chalk.bgYellow(chalk.black(now.toLocaleString()))
+      : now.toLocaleString(),
+    epoch: Math.floor(now.getTime() / 1000).toString(),
+    level: logString(level, useColors),
+    duration: durationString(store.beforeTime, useColors),
+    method: methodString(request.method, useColors),
+    pathname: pathString(request),
+    status: statusString(data.status || 200, useColors),
+    message: data.message || '',
+    ip:
+      options?.config?.ip && request.headers.get('x-forwarded-for')
+        ? `IP: ${request.headers.get('x-forwarded-for')}`
+        : ''
+  }
 
-  const logFormat =
-    options?.config?.customLogFormat ||
-    '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
+  const logFormat = options?.config?.customLogFormat || defaultLogFormat
 
-  return logFormat
-    .replace('{now}', nowStr)
-    .replace('{level}', levelStr)
-    .replace('{duration}', durationStr)
-    .replace('{method}', methodStr)
-    .replace('{pathname}', pathnameStr || '')
-    .replace('{status}', statusStr)
-    .replace('{message}', messageStr)
-    .replace('{ip}', ipStr || '')
+  return logFormat.replace(/{(\w+)}/g, (_, key: string) => {
+    if (key in components) {
+      return components[key as keyof LogComponents] || ''
+    }
+    return ''
+  })
 }

package/src/logger/createLogger.ts

@@ -1,3 +1,7 @@
+import { buildLogMessage } from '~/logger/buildLogMessage'
+import { filterLog } from '~/logger/filter'
+import { logToFile } from '~/logger/logToFile'
+import { logToTransports } from '~/transports'
 import {
   LogData,
   Logger,
@@ -7,10 +11,6 @@ import {
   StoreData
 } from '~/types'
 
-import { buildLogMessage } from './buildLogMessage'
-import { filterLog } from './filter'
-import { logToFile } from './logToFile'
-
 /**
  * Logs a message to the console and optionally to a file.
  *
@@ -32,16 +32,26 @@ async function log(
   const logMessage = buildLogMessage(level, request, data, store, options, true)
   console.log(logMessage)
 
+  const promises = []
+
   if (options?.config?.logFilePath) {
-    await logToFile(
-      options.config.logFilePath,
-      level,
-      request,
-      data,
-      store,
-      options
+    promises.push(
+      logToFile(
+        options.config.logFilePath,
+        level,
+        request,
+        data,
+        store,
+        options
+      )
     )
   }
+
+  if (options?.config?.transports?.length) {
+    promises.push(logToTransports(level, request, data, store, options))
+  }
+
+  await Promise.all(promises)
 }
 
 /**
@@ -52,7 +62,7 @@ async function log(
  */
 export function createLogger(options?: Options): Logger {
   return {
-    log: async (level, request, data, store) =>
+    log: (level, request, data, store) =>
       log(level, request, data, store, options),
     customLogFormat: options?.config?.customLogFormat
   }

package/src/logger/filter.ts

@@ -1,5 +1,10 @@
 import { LogLevel, Options } from '~/types'
 
+const checkFilter = (filterValue: any, value: any) =>
+  Array.isArray(filterValue)
+    ? filterValue.includes(value)
+    : filterValue === value
+
 /**
  * Filters log messages.
  *
@@ -18,11 +23,6 @@ export function filterLog(
   const filter = options?.config?.logFilter
   if (!filter) return true
 
-  const checkFilter = (filterValue: any, value: any) =>
-    Array.isArray(filterValue)
-      ? filterValue.includes(value)
-      : filterValue === value
-
   return (
     (!filter.level || checkFilter(filter.level, logLevel)) &&
     (!filter.status || checkFilter(filter.status, status)) &&

package/src/logger/handleHttpError.ts

@@ -1,7 +1,6 @@
+import { buildLogMessage } from '~/logger/buildLogMessage'
 import { HttpError, Options, RequestInfo, StoreData } from '~/types'
 
-import { buildLogMessage } from './buildLogMessage'
-
 /**
  * Handles an HTTP error and logs it.
  *
@@ -10,19 +9,14 @@ import { buildLogMessage } from './buildLogMessage'
  * @param {StoreData} store The store data.
  * @param {Options} options The logger options.
  */
-export async function handleHttpError(
+export function handleHttpError(
   request: RequestInfo,
   error: HttpError,
   store: StoreData,
   options?: Options
-): Promise<void> {
+): void {
   const statusCode = error.status || 500
-  const logMessage = buildLogMessage(
-    'ERROR',
-    request,
-    { status: statusCode },
-    store,
-    options
+  console.error(
+    buildLogMessage('ERROR', request, { status: statusCode }, store, options)
   )
-  console.error(logMessage)
 }

package/src/logger/index.ts

@@ -1,2 +1,2 @@
-export { createLogger } from './createLogger'
-export { handleHttpError } from './handleHttpError'
+export { createLogger } from '~/logger/createLogger'
+export { handleHttpError } from '~/logger/handleHttpError'

package/src/logger/logToFile.ts

@@ -1,9 +1,10 @@
 import { promises as fs } from 'fs'
 import { dirname } from 'path'
 
+import { buildLogMessage } from '~/logger/buildLogMessage'
 import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
 
-import { buildLogMessage } from './buildLogMessage'
+const dirCache = new Set<string>()
 
 /**
  * Ensures that the directory exists. If not, it creates the directory.
@@ -12,7 +13,10 @@ import { buildLogMessage } from './buildLogMessage'
  */
 async function ensureDirectoryExists(filePath: string): Promise<void> {
   const dir = dirname(filePath)
-  await fs.mkdir(dir, { recursive: true })
+  if (!dirCache.has(dir)) {
+    await fs.mkdir(dir, { recursive: true })
+    dirCache.add(dir)
+  }
 }
 
 /**
@@ -36,5 +40,5 @@ export async function logToFile(
   await ensureDirectoryExists(filePath)
   const logMessage =
     buildLogMessage(level, request, data, store, options, false) + '\n'
-  await fs.appendFile(filePath, logMessage)
+  await fs.appendFile(filePath, logMessage, { flag: 'a' })
 }

package/src/transports/index.ts

@@ -0,0 +1,22 @@
+import { buildLogMessage } from '~/logger/buildLogMessage'
+import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
+
+export async function logToTransports(
+  level: LogLevel,
+  request: RequestInfo,
+  data: LogData,
+  store: StoreData,
+  options?: Options
+): Promise<void> {
+  if (!options?.config?.transports || options.config.transports.length === 0) {
+    return
+  }
+
+  const message = buildLogMessage(level, request, data, store, options, false)
+
+  const promises = options.config.transports.map(transport =>
+    transport.log(level, message, { request, data, store })
+  )
+
+  await Promise.all(promises)
+}

package/src/types.ts

@@ -31,6 +31,18 @@ interface Logger {
   customLogFormat?: string
 }
 
+interface LogComponents {
+  now: string
+  epoch: string
+  level: string
+  duration: string
+  method: string
+  pathname: string | undefined
+  status: string
+  message: string
+  ip: string
+}
+
 interface StoreData {
   beforeTime: bigint
 }
@@ -44,9 +56,24 @@ class HttpError extends Error {
   }
 }
 
+interface TransportFunction {
+  (
+    level: LogLevel,
+    message: string,
+    meta: {
+      request: RequestInfo
+      data: LogData
+      store: StoreData
+    }
+  ): Promise<void> | void
+}
+
+interface Transport {
+  log: TransportFunction
+}
+
 interface Options {
   config?: {
-    ip?: boolean
     customLogFormat?: string
     logFilePath?: string
     logFilter?: {
@@ -54,18 +81,23 @@ interface Options {
       method?: string | string[]
       status?: number | number[]
     } | null
+    ip?: boolean
     showBanner?: boolean
+    transports?: Transport[]
   }
 }
 
 export {
   ColorMap,
   HttpError,
+  LogComponents,
   LogData,
   Logger,
   LogLevel,
   Options,
   RequestInfo,
   Server,
-  StoreData
+  StoreData,
+  Transport,
+  TransportFunction
 }

package/src/utils/duration.ts

@@ -1,5 +1,12 @@
 import chalk from 'chalk'
 
+const timeUnits = [
+  { unit: 's', threshold: 1e9, decimalPlaces: 2 },
+  { unit: 'ms', threshold: 1e6, decimalPlaces: 0 },
+  { unit: 'µs', threshold: 1e3, decimalPlaces: 0 },
+  { unit: 'ns', threshold: 1, decimalPlaces: 0 }
+]
+
 /**
  * Converts a time difference into a formatted string with the most appropriate time unit.
  *
@@ -8,38 +15,19 @@ import chalk from 'chalk'
  * @returns {string} A formatted duration string including the time unit.
  */
 function durationString(beforeTime: bigint, useColors: boolean): string {
-  const currentTime = process.hrtime.bigint()
-  const nanoseconds = Number(currentTime - beforeTime)
-
-  const timeUnits = [
-    { unit: 's', threshold: 1e9, decimalPlaces: 2 },
-    { unit: 'ms', threshold: 1e6, decimalPlaces: 0 },
-    { unit: 'µs', threshold: 1e3, decimalPlaces: 0 }
-  ]
+  const nanoseconds = Number(process.hrtime.bigint() - beforeTime)
 
   for (const { unit, threshold, decimalPlaces } of timeUnits) {
     if (nanoseconds >= threshold) {
       const value = (nanoseconds / threshold).toFixed(decimalPlaces)
-      return formatTime(value, unit, useColors)
+      const timeStr = `${value}${unit}`.padStart(8).padEnd(16)
+      return useColors ? chalk.gray(timeStr) : timeStr
     }
   }
 
-  return formatTime(nanoseconds.toString(), 'ns', useColors)
-}
-
-/**
- * Formats the time value with the given unit and applies chalk styling.
- *
- * @param {string} value - The time value.
- * @param {string} unit - The time unit.
- * @param {boolean} useColors - Whether to apply colors to the output.
- * @returns {string} Styled time string.
- */
-function formatTime(value: string, unit: string, useColors: boolean): string {
-  const timeStr = `${value}${unit}`
   return useColors
-    ? chalk.gray(timeStr).padStart(8).padEnd(16)
-    : timeStr.padStart(8).padEnd(16)
+    ? chalk.gray('0ns'.padStart(8).padEnd(16))
+    : '0ns'.padStart(8).padEnd(16)
 }
 
 export default durationString

package/src/utils/log.ts

@@ -1,6 +1,5 @@
 import { LogLevel } from '~/types'
-
-import { LogLevelColorMap } from './colorMapping'
+import { LogLevelColorMap } from '~/utils/colorMapping'
 
 /**
  * Converts the log level to a string.
@@ -9,7 +8,7 @@ import { LogLevelColorMap } from './colorMapping'
  * @param {boolean} useColors - Whether to apply colors to the output.
  * @returns {string} The log level as a string.
  */
-function logString(level: LogLevel, useColors: boolean): string {
+const logString = (level: LogLevel, useColors: boolean): string => {
   const levelStr = level.toUpperCase()
   return useColors
     ? LogLevelColorMap[levelStr]?.(levelStr.padEnd(7)) || levelStr

package/src/utils/method.ts

@@ -1,4 +1,4 @@
-import { HttpMethodColorMap } from './colorMapping'
+import { HttpMethodColorMap } from '~/utils/colorMapping'
 
 /**
  * Converts an HTTP request method to a colored string representation.

package/src/utils/path.ts

@@ -6,7 +6,7 @@ import { RequestInfo } from '~/types'
  * @param {RequestInfo} requestInfo The request info.
  * @returns {string | undefined} The path string.
  */
-function pathString(requestInfo: RequestInfo): string | undefined {
+const pathString = (requestInfo: RequestInfo): string | undefined => {
   try {
     return new URL(requestInfo.url).pathname
   } catch {

package/src/utils/start.ts

@@ -7,7 +7,7 @@ import { Options, Server } from '~/types'
  * @param {number} width The box width.
  * @returns {string} The box text.
  */
-function createBoxText(text: string, width: number): string {
+const createBoxText = (text: string, width: number): string => {
   const paddingLength = Math.max(0, (width - text.length) / 2)
   const padding = ' '.repeat(paddingLength)
   return `${padding}${text}${padding}`.padEnd(width)
@@ -29,14 +29,15 @@ function startServer(config: Server, options?: Options): void {
     const message = `🦊 Elysia is running at ${protocol}://${hostname}:${port}`
     const boxWidth = Math.max(title.length, message.length) + 4
     const border = '─'.repeat(boxWidth)
+    const emptyLine = createBoxText('', boxWidth)
 
     console.log(`
       ┌${border}┐
-      │${createBoxText('', boxWidth)}│
+      │${emptyLine}│
       │${createBoxText(title, boxWidth)}│
-      │${createBoxText('', boxWidth)}│
+      │${emptyLine}│
       │${createBoxText(message, boxWidth)}│
-      │${createBoxText('', boxWidth)}│
+      │${emptyLine}│
       └${border}┘
     `)
   } else {

package/src/utils/status.ts

@@ -7,7 +7,7 @@ import chalk from 'chalk'
  * @param {boolean} useColors - Whether to apply colors to the output.
  * @returns {string} The status code as a string.
  */
-function statusString(status: number, useColors: boolean): string {
+const statusString = (status: number, useColors: boolean): string => {
   const color =
     status >= 500
       ? 'red'