@verdaccio/logger 9.0.0-next-9.3 → 9.0.0-next-9.5

package/src/index.ts

@@ -0,0 +1,28 @@
+import pino from 'pino';
+
+import type { Logger, LoggerConfigItem } from '@verdaccio/types';
+
+import { prepareSetup } from './logger';
+
+export { createLogger, prepareSetup, willUseTransport } from './logger';
+export type { LogPlugin, LoggerConfig } from './logger';
+export { default as prettifyTransport, autoEnd, buildPretty, buildSafeSonicBoom } from './prettify';
+export { hasColors } from './colors';
+export { fillInMsgTemplate, printMessage } from './formatter';
+export { createPrettyTransport, isPrettyFormat } from './transport';
+export type { LevelCode } from './levels';
+export { formatLoggingDate, padRight } from './utils';
+
+/**
+ * Initialize the logger singleton.
+ */
+export async function setup(options: LoggerConfigItem): Promise<Logger> {
+  if (typeof logger !== 'undefined') {
+    return logger;
+  }
+
+  logger = await prepareSetup(options, pino);
+  return logger;
+}
+
+export let logger: Logger;

package/src/levels.ts

@@ -0,0 +1,60 @@
+import { black, blue, cyan, green, magenta, red, white, yellow } from 'colorette';
+
+export type LogLevel = 'trace' | 'debug' | 'info' | 'http' | 'warn' | 'error' | 'fatal';
+
+export type LevelCode = number;
+
+export function calculateLevel(levelCode: LevelCode): LogLevel {
+  switch (true) {
+    case levelCode === 10:
+      return 'trace';
+    case levelCode === 20:
+      return 'debug';
+    case levelCode === 25:
+      return 'http';
+    case levelCode === 30:
+      return 'info';
+    case levelCode === 40:
+      return 'warn';
+    case levelCode === 50:
+      return 'error';
+    case levelCode === 60:
+      return 'fatal';
+    default:
+      return 'fatal';
+  }
+}
+
+export const levelsColors = {
+  fatal: red,
+  error: red,
+  warn: yellow,
+  http: magenta,
+  info: cyan,
+  debug: green,
+  trace: white,
+};
+
+enum ARROWS {
+  LEFT = '<--',
+  RIGHT = '-->',
+  EQUAL = '-=-',
+  NEUTRAL = '---',
+}
+
+export const subSystemLevels = {
+  color: {
+    in: green(ARROWS.LEFT),
+    out: yellow(ARROWS.RIGHT),
+    auth: blue(ARROWS.NEUTRAL),
+    fs: black(ARROWS.EQUAL),
+    default: blue(ARROWS.NEUTRAL),
+  },
+  white: {
+    in: ARROWS.LEFT,
+    out: ARROWS.RIGHT,
+    auth: ARROWS.NEUTRAL,
+    fs: ARROWS.EQUAL,
+    default: ARROWS.NEUTRAL,
+  },
+};

package/src/logger.ts

@@ -0,0 +1,126 @@
+// <reference types="node" />
+import buildDebug from 'debug';
+import type { LoggerOptions } from 'pino';
+
+import type { Logger, LoggerConfigItem, LoggerFormat } from '@verdaccio/types';
+
+import { fillInMsgTemplate } from './formatter';
+import { createPrettyTransport, isPrettyFormat } from './transport';
+
+const debug = buildDebug('verdaccio:logger');
+
+function isProd() {
+  return process.env.NODE_ENV === 'production';
+}
+
+const DEFAULT_LOG_FORMAT = isProd() ? 'json' : 'pretty';
+debug('default log format: %s', DEFAULT_LOG_FORMAT);
+
+export type LogPlugin = {
+  dest: string;
+  options?: any[];
+};
+
+export function createLogger(
+  options: LoggerConfigItem = { level: 'http' },
+  destination: NodeJS.WritableStream | undefined,
+  format: LoggerFormat = DEFAULT_LOG_FORMAT,
+  pino
+): any {
+  debug('setup logger');
+  let pinoConfig: LoggerOptions = {
+    customLevels: {
+      http: 25,
+    },
+    level: options.level,
+    serializers: {
+      err: pino.stdSerializers.err,
+      req: pino.stdSerializers.req,
+      res: pino.stdSerializers.res,
+    },
+    redact: options.redact,
+  };
+
+  debug('has prettifier? %o', !isProd());
+  let logger;
+  // pretty logs are not allowed in production for performance reasons
+  if (isPrettyFormat(format) && isProd() === false) {
+    const transport = createPrettyTransport(pino, options, format);
+    logger = pino(pinoConfig, transport);
+  } else {
+    pinoConfig = {
+      ...pinoConfig,
+      // https://getpino.io/#/docs/api?id=hooks-object
+      hooks: {
+        logMethod(args: [obj: unknown, msg?: string, ...rest: unknown[]], method, _level) {
+          const [templateObject, message, ...otherArgs] = args;
+          const templateVars =
+            !!templateObject && typeof templateObject === 'object'
+              ? Object.getOwnPropertyNames(templateObject)
+              : [];
+          if (!message || !templateVars.length) return method.apply(this, args);
+          const hydratedMessage = fillInMsgTemplate(message, templateObject as any, false);
+          return method.apply(this, [templateObject, hydratedMessage, ...otherArgs] as any);
+        },
+      },
+    };
+    logger = pino(pinoConfig, destination);
+  }
+
+  if (process.env.DEBUG) {
+    logger.on('level-change', (lvl, val, prevLvl, prevVal, instance) => {
+      if (logger !== instance) {
+        return;
+      }
+      debug('%s (%d) was changed to %s (%d)', lvl, val, prevLvl, prevVal);
+    });
+  }
+
+  return logger;
+}
+
+const DEFAULT_LOGGER_CONF: LoggerConfigItem = {
+  type: 'stdout',
+  format: 'pretty',
+  level: 'http',
+};
+
+export type LoggerConfig = LoggerConfigItem;
+
+export function willUseTransport(format: LoggerFormat | undefined): boolean {
+  const resolvedFormat = format ?? (isProd() ? 'json' : 'pretty');
+  return isPrettyFormat(resolvedFormat) && isProd() === false;
+}
+
+export async function prepareSetup(
+  options: LoggerConfigItem = DEFAULT_LOGGER_CONF,
+  pino
+): Promise<Logger> {
+  let loggerConfig = options;
+  if (!loggerConfig?.level) {
+    loggerConfig = {
+      ...loggerConfig,
+      level: 'http',
+    };
+  }
+  if (loggerConfig.type === 'file') {
+    debug('logging file enabled');
+    // Pretty format uses a pino transport that creates its own destination stream,
+    // so no destination is needed here.
+    if (willUseTransport(loggerConfig.format)) {
+      return createLogger(loggerConfig, undefined, loggerConfig.format, pino);
+    }
+    // For file destinations (json format), wait for the fd to be ready
+    // so we fail fast on bad paths / permissions instead of losing early logs
+    const destination = pino.destination(loggerConfig.path);
+    await new Promise<void>((resolve, reject) => {
+      destination.once('ready', resolve);
+      destination.once('error', reject);
+    });
+    debug('file destination ready: %s', loggerConfig.path);
+    process.on('SIGUSR2', () => destination.reopen());
+    return createLogger(loggerConfig, destination, loggerConfig.format, pino);
+  }
+  debug('logging stdout enabled');
+  return createLogger(loggerConfig, pino.destination(1), loggerConfig.format, pino);
+}

package/src/prettify.ts

@@ -0,0 +1,119 @@
+import type { WriteStream } from 'node:fs';
+import { Transform, pipeline } from 'node:stream';
+import { isMainThread } from 'node:worker_threads';
+import build from 'pino-abstract-transport';
+import type { SonicBoomOpts } from 'sonic-boom';
+import SonicBoom from 'sonic-boom';
+
+import { hasColors } from './colors';
+import { fillInMsgTemplate, printMessage } from './formatter';
+import type { PrettyOptionsExtended } from './types';
+
+export { fillInMsgTemplate };
+
+function noop() {}
+
+/**
+ * Creates a safe SonicBoom instance
+ *
+ * @param {object} opts Options for SonicBoom
+ *
+ * @returns {object} A new SonicBoom stream
+ */
+export function buildSafeSonicBoom(opts: SonicBoomOpts) {
+  const stream = new SonicBoom(opts);
+  stream.on('error', filterBrokenPipe);
+  if (!opts.sync && isMainThread) {
+    setupOnExit(stream);
+  }
+  return stream;
+
+  function filterBrokenPipe(err) {
+    if (err.code === 'EPIPE') {
+      // @ts-ignore
+      stream.write = noop;
+      stream.end = noop;
+      stream.flushSync = noop;
+      stream.destroy = noop;
+      return;
+    }
+    stream.removeListener('error', filterBrokenPipe);
+  }
+}
+
+export function autoEnd(stream: SonicBoom & { destroyed?: boolean }, eventName: string) {
+  if (stream.destroyed) {
+    return;
+  }
+
+  if (eventName === 'beforeExit') {
+    stream.flush();
+    stream.on('drain', function () {
+      stream.end();
+    });
+  } else {
+    // Guard against SonicBoom not being ready (file not yet opened)
+    // to prevent "sonic boom is not ready yet" crash on early process exit
+    try {
+      stream.flushSync();
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message?.includes('not ready')) {
+        // Stream not ready, nothing to flush
+        return;
+      }
+      // Re-throw real I/O errors (disk full, permission denied, etc.)
+      throw err;
+    }
+  }
+}
+
+function setupOnExit(stream) {
+  // WeakRef/FinalizationRegistry are guaranteed available in Node 20+ (pino v10 minimum)
+  const onExit = require('on-exit-leak-free');
+  onExit.register(stream, autoEnd);
+  stream.on('close', function () {
+    onExit.unregister(stream);
+  });
+}
+
+export { hasColors } from './colors';
+
+export function buildPretty(opts: PrettyOptionsExtended) {
+  return (chunk) => {
+    const colors = hasColors(opts.colors);
+    return printMessage(chunk, { prettyStamp: opts.prettyStamp }, colors);
+  };
+}
+
+export default function (opts) {
+  const pretty = buildPretty(opts);
+  // @ts-ignore
+  return build(function (source) {
+    const stream = new Transform({
+      objectMode: true,
+      autoDestroy: true,
+      transform(chunk, enc, cb) {
+        const line = pretty(chunk) + '\n';
+        cb(null, line);
+      },
+    });
+    const destination = buildSafeSonicBoom({
+      dest: opts.destination || 1,
+      // Defaults to async (false). The transport runs in a worker thread,
+      // so sync only blocks the worker, not the main thread.
+      // Can be set to true via config for deterministic log ordering (like console.log).
+      sync: opts.sync ?? false,
+    }) as unknown as WriteStream;
+
+    source.on('unknown', function (line) {
+      destination.write(line + '\n');
+    });
+
+    pipeline(source, stream, destination, (err) => {
+      if (err) {
+        console.error('prettify pipeline error ', err);
+      }
+    });
+    return stream;
+  });
+}

package/src/transport.ts

@@ -0,0 +1,39 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import type { LoggerConfigItem, LoggerFormat } from '@verdaccio/types';
+
+import { hasColors } from './colors';
+
+// Pino transports run in a worker thread and require an absolute path to a built JS file.
+// __dirname works in CJS; import.meta.url works in ESM (Node 20+).
+function getCurrentDir(): string {
+  if (typeof __dirname !== 'undefined') {
+    return __dirname;
+  }
+  // @ts-ignore -- import.meta.url requires module: es2020+ but vite preserves it for ESM output
+  return dirname(fileURLToPath(import.meta.url));
+}
+const prettifyPath = join(getCurrentDir(), '..', 'build', 'prettify.js');
+
+export function isPrettyFormat(format: LoggerFormat | undefined): boolean {
+  return ['pretty-timestamped', 'pretty'].includes(format ?? 'pretty');
+}
+
+/**
+ * Create a pino pretty transport for non-production environments.
+ */
+export function createPrettyTransport(pino: any, options: LoggerConfigItem, format: LoggerFormat) {
+  return pino.transport({
+    target: prettifyPath,
+    options: {
+      destination: options.path || 1,
+      colors: hasColors(options.colors),
+      prettyStamp: format === 'pretty-timestamped',
+      sync: options.sync ?? false,
+    },
+    worker: {
+      name: 'verdaccio-logger-prettify',
+    },
+  });
+}

package/src/types.ts

@@ -0,0 +1,6 @@
+import type { LoggerOptions } from 'pino';
+
+export interface PrettyOptionsExtended extends LoggerOptions {
+  prettyStamp: boolean;
+  colors?: boolean;
+}

package/src/utils.ts

@@ -0,0 +1,18 @@
+import dayjs from 'dayjs';
+
+export const FORMAT_DATE = 'YYYY-MM-DD HH:mm:ss';
+export const CUSTOM_PAD_LENGTH = 1;
+
+export function isObject(obj: unknown): boolean {
+  return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+}
+
+export function padRight(message: string, max = message.length + CUSTOM_PAD_LENGTH) {
+  return message.padEnd(max, ' ');
+}
+
+export function formatLoggingDate(time: number, message: string): string {
+  const timeFormatted = dayjs(time).format(FORMAT_DATE);
+
+  return `[${timeFormatted}] ${message}`;
+}

package/test/__snapshots__/formatter.spec.ts.snap

@@ -0,0 +1,21 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`formatter > printMessage > should display a bytes request 1`] = `"fatal<-- 200, user: null(127.0.0.1), req: 'GET /verdaccio', bytes: 0/150186"`;
+
+exports[`formatter > printMessage > should display a resource request 1`] = `"info <-- 127.0.0.1 requested 'GET /verdaccio'"`;
+
+exports[`formatter > printMessage > should display a streaming request 1`] = `"fatal--> 304, req: 'GET https://registry.npmjs.org/verdaccio' (streaming)"`;
+
+exports[`formatter > printMessage > should display an error request 1`] = `"fatal--> ERR, req: 'GET https://registry.fake.org/aaa', error: getaddrinfo ENOTFOUND registry.fake.org"`;
+
+exports[`formatter > printMessage > should display an fatal request 1`] = `"fatal--> ERR, req: 'GET https://registry.fake.org/aaa', error: fatal error"`;
+
+exports[`formatter > printMessage > should display config file 1`] = `"warn --- config file  - /Users/user/.config/verdaccio/config/config.yaml"`;
+
+exports[`formatter > printMessage > should display custom log message 1`] = `"fatal--- custom - foo - undefined"`;
+
+exports[`formatter > printMessage > should display trace level 1`] = `"trace--- [trace]  - foo"`;
+
+exports[`formatter > printMessage > should display trace level with pretty stamp 1`] = `"[formatted-date] trace--- [trace]  - foo"`;
+
+exports[`formatter > printMessage > should display version and http address 1`] = `"warn --- http address - http://localhost:4873/ - verdaccio/5.0.0"`;

package/test/createLogger.spec.ts

@@ -0,0 +1,22 @@
+import { Writable } from 'node:stream';
+import pino from 'pino';
+import { describe, expect, test } from 'vitest';
+
+import { createLogger } from '../src';
+
+describe('logger test', () => {
+  describe('json format', () => {
+    test('should write json to a stream', () => {
+      const stream = new Writable({
+        write(chunk, encoding, callback) {
+          expect(JSON.parse(chunk.toString())).toEqual(
+            expect.objectContaining({ level: 30, msg: 'test' })
+          );
+          callback();
+        },
+      });
+      const logger = createLogger({ level: 'http' }, stream, 'json', pino);
+      logger.info('test');
+    });
+  });
+});

package/test/formatter.spec.ts

@@ -0,0 +1,214 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { printMessage } from '../src';
+import type { LevelCode } from '../src';
+
+vi.mock('dayjs', () => ({
+  __esModule: true,
+  default: () => ({
+    format: () => 'formatted-date',
+  }),
+}));
+
+describe('formatter', () => {
+  const prettyfierOptions = { messageKey: 'msg', levelFirst: true, prettyStamp: false };
+  describe('printMessage', () => {
+    test('should display config file', () => {
+      const log = {
+        level: 40,
+        time: 1585410824129,
+        v: 1,
+        pid: 27029,
+        hostname: 'localhost',
+        file: '/Users/user/.config/verdaccio/config/config.yaml',
+        msg: 'config file  - @{file}',
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display trace level', () => {
+      const log = {
+        level: 10,
+        foo: 'foo',
+        msg: '[trace]  - @{foo}',
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display trace level with pretty stamp', () => {
+      const log = {
+        level: 10,
+        foo: 'foo',
+        time: 1585411248203,
+        msg: '[trace]  - @{foo}',
+      };
+
+      expect(
+        printMessage(
+          log,
+          Object.assign({}, prettyfierOptions, {
+            prettyStamp: true,
+          }),
+          false
+        )
+      ).toMatchSnapshot();
+    });
+
+    test('should display a bytes request', () => {
+      const log = {
+        level: 35,
+        time: 1585411248203,
+        v: 1,
+        pid: 27029,
+        hostname: 'macbook-touch',
+        sub: 'in',
+        request: { method: 'GET', url: '/verdaccio' },
+        user: null,
+        remoteIP: '127.0.0.1',
+        status: 200,
+        error: undefined,
+        bytes: { in: 0, out: 150186 },
+        msg:
+          "@{status}, user: @{user}(@{remoteIP}), req: '@{request.method} @{request.url}', " +
+          'bytes: @{bytes.in}/@{bytes.out}',
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display an error request', () => {
+      const log = {
+        level: 54,
+        time: 1585416029123,
+        v: 1,
+        pid: 30032,
+        hostname: 'macbook-touch',
+        sub: 'out',
+        err: {
+          type: 'Error',
+          message: 'getaddrinfo ENOTFOUND registry.fake.org',
+          stack:
+            'Error: getaddrinfo ENOTFOUND registry.fake.org\n' +
+            '    at GetAddrInfoReqWrap.onlookup [as oncomplete] (dns.js:60:26)',
+          errno: -3008,
+          code: 'ENOTFOUND',
+          syscall: 'getaddrinfo',
+          hostname: 'registry.fake.org',
+        },
+        request: { method: 'GET', url: 'https://registry.fake.org/aaa' },
+        status: 'ERR',
+        error: 'getaddrinfo ENOTFOUND registry.fake.org',
+        bytes: { in: 0, out: 0 },
+        msg: "@{!status}, req: '@{request.method} @{request.url}', error: @{!error}",
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display an fatal request', () => {
+      const log = {
+        level: 60,
+        time: 1585416029123,
+        v: 1,
+        pid: 30032,
+        hostname: 'macbook-touch',
+        sub: 'out',
+        err: {
+          type: 'Error',
+          message: 'fatal error',
+          stack: '....',
+          errno: -3008,
+          code: 'ENOTFOUND',
+        },
+        request: { method: 'GET', url: 'https://registry.fake.org/aaa' },
+        status: 'ERR',
+        error: 'fatal error',
+        bytes: { in: 0, out: 0 },
+        msg: "@{!status}, req: '@{request.method} @{request.url}', error: @{!error}",
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display a streaming request', () => {
+      const log = {
+        level: 35,
+        time: 1585411247920,
+        v: 1,
+        pid: 27029,
+        hostname: 'macbook-touch',
+        sub: 'out',
+        request: { method: 'GET', url: 'https://registry.npmjs.org/verdaccio' },
+        status: 304,
+        msg: "@{!status}, req: '@{request.method} @{request.url}' (streaming)",
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display version and http address', () => {
+      const log = {
+        level: 40,
+        time: 1585410824322,
+        v: 1,
+        pid: 27029,
+        hostname: 'macbook-touch',
+        addr: 'http://localhost:4873/',
+        version: 'verdaccio/5.0.0',
+        msg: 'http address - @{addr} - @{version}',
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display custom log message', () => {
+      const level: LevelCode = 15;
+      const log = {
+        level,
+        something: 'foo',
+        msg: 'custom - @{something} - @{missingParam}',
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+
+    test('should display a resource request', () => {
+      const log = {
+        level: 30,
+        time: 1585411247622,
+        v: 1,
+        pid: 27029,
+        hostname: 'macbook-touch',
+        sub: 'in',
+        req: {
+          id: undefined,
+          method: 'GET',
+          url: '/verdaccio',
+          headers: {
+            connection: 'keep-alive',
+            'user-agent': 'npm/6.13.2 node/v13.1.0 darwin x64',
+            'npm-in-ci': 'false',
+            'npm-scope': '',
+            'npm-session': 'afebb4748178bd4b',
+            referer: 'view verdaccio',
+            'pacote-req-type': 'packument',
+            'pacote-pkg-id': 'registry:verdaccio',
+            accept: 'application/json',
+            authorization: '<Classified>',
+            'if-none-match': '"fd6440ba2ad24681077664d8f969e5c3"',
+            'accept-encoding': 'gzip,deflate',
+            host: 'localhost:4873',
+          },
+          remoteAddress: '127.0.0.1',
+          remotePort: 57968,
+        },
+        ip: '127.0.0.1',
+        msg: "@{ip} requested '@{req.method} @{req.url}'",
+      };
+
+      expect(printMessage(log, prettyfierOptions, false)).toMatchSnapshot();
+    });
+  });
+});