velocky 0.0.1-security → 1.0.7

package/test/types/pino.ts

@@ -0,0 +1,78 @@
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import pinoPretty from 'pino-pretty'
+import { LoggerOptions, StreamEntry, pino } from '../../pino'
+
+const destination = join(
+    tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+)
+
+// Single
+const transport = pino.transport({
+    target: 'pino-pretty',
+    options: { some: 'options for', the: 'transport' }
+})
+const logger = pino(transport)
+logger.setBindings({ some: 'bindings' })
+logger.info('test2')
+logger.flush()
+
+const transport2 = pino.transport({
+    target: 'pino-pretty',
+})
+const logger2 = pino(transport2)
+logger2.info('test2')
+
+
+// Multiple
+
+const transports = pino.transport({targets: [
+    {
+        level: 'info',
+        target: 'pino-pretty',
+        options: { some: 'options for', the: 'transport' }
+    },
+    {
+        level: 'trace',
+        target: 'pino/file',
+        options: { destination }
+    }
+]})
+const loggerMulti = pino(transports)
+loggerMulti.info('test2')
+
+// custom levels
+
+const customLevels = {
+    customDebug   : 1,
+    info    : 2,
+    customNetwork : 3,
+    customError   : 4,
+};
+
+type CustomLevels = keyof typeof customLevels;
+
+const pinoOpts = {
+    useOnlyCustomLevels: true,
+    customLevels: customLevels,
+    level: 'customDebug',
+} satisfies LoggerOptions;
+
+const multistreamOpts = {
+    dedupe: true,
+    levels: customLevels
+};
+
+const streams: StreamEntry<CustomLevels>[] = [
+    { level : 'customDebug',   stream : pinoPretty() },
+    { level : 'info',    stream : pinoPretty() },
+    { level : 'customNetwork', stream : pinoPretty() },
+    { level : 'customError',   stream : pinoPretty() },
+];
+
+const loggerCustomLevel = pino(pinoOpts, pino.multistream(streams, multistreamOpts));
+loggerCustomLevel.customDebug('test3')
+loggerCustomLevel.info('test4')
+loggerCustomLevel.customError('test5')
+loggerCustomLevel.customNetwork('test6')

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "lib": [ "es2015", "dom" ],
+    "module": "commonjs",
+    "noEmit": true,
+    "strict": true,
+    "esModuleInterop": true,
+  },
+  "exclude": [
+    "./test/types/*.test-d.ts",
+    "./*.d.ts"
+  ]
+}

package/velocky.js

@@ -0,0 +1,236 @@
+'use strict'
+
+const os = require('node:os')
+const stdSerializers = require('pino-std-serializers')
+const caller = require('./lib/caller')
+const redaction = require('./lib/redaction')
+const time = require('./lib/time')
+const proto = require('./lib/proto')
+const writer = require('./lib/writer');
+const symbols = require('./lib/symbols')
+const { configure } = require('safe-stable-stringify')
+const { assertDefaultLevelFound, mappings, genLsCache, genLevelComparison, assertLevelComparison } = require('./lib/levels')
+const { DEFAULT_LEVELS, SORTING_ORDER } = require('./lib/constants')
+const {
+  createArgsNormalizer,
+  asChindings,
+  buildSafeSonicBoom,
+  buildFormatters,
+  stringify,
+  normalizeDestFileDescriptor,
+  noop
+} = require('./lib/tools')
+const { version } = require('./lib/meta')
+const {
+  chindingsSym,
+  redactFmtSym,
+  serializersSym,
+  timeSym,
+  timeSliceIndexSym,
+  streamSym,
+  stringifySym,
+  stringifySafeSym,
+  stringifiersSym,
+  setLevelSym,
+  endSym,
+  formatOptsSym,
+  messageKeySym,
+  errorKeySym,
+  nestedKeySym,
+  mixinSym,
+  levelCompSym,
+  useOnlyCustomLevelsSym,
+  formattersSym,
+  hooksSym,
+  nestedKeyStrSym,
+  mixinMergeStrategySym,
+  msgPrefixSym
+} = symbols
+const { epochTime, nullTime } = time
+const { pid } = process
+const hostname = os.hostname()
+const defaultErrorSerializer = stdSerializers.err
+const defaultOptions = {
+  level: 'info',
+  levelComparison: SORTING_ORDER.ASC,
+  levels: DEFAULT_LEVELS,
+  messageKey: 'msg',
+  errorKey: 'err',
+  nestedKey: null,
+  enabled: true,
+  base: { pid, hostname },
+  serializers: Object.assign(Object.create(null), {
+    err: defaultErrorSerializer
+  }),
+  formatters: Object.assign(Object.create(null), {
+    bindings (bindings) {
+      return bindings
+    },
+    level (label, number) {
+      return { level: number }
+    }
+  }),
+  hooks: {
+    logMethod: undefined,
+    streamWrite: undefined
+  },
+  timestamp: epochTime,
+  name: undefined,
+  redact: null,
+  customLevels: null,
+  useOnlyCustomLevels: false,
+  depthLimit: 5,
+  edgeLimit: 100
+}
+
+const normalize = createArgsNormalizer(defaultOptions)
+
+const serializers = Object.assign(Object.create(null), stdSerializers)
+
+function pino (...args) {
+  writer()
+  const instance = {}
+  const { opts, stream } = normalize(instance, caller(), ...args)
+
+  if (opts.level && typeof opts.level === 'string' && DEFAULT_LEVELS[opts.level.toLowerCase()] !== undefined) opts.level = opts.level.toLowerCase()
+
+  const {
+    redact,
+    crlf,
+    serializers,
+    timestamp,
+    messageKey,
+    errorKey,
+    nestedKey,
+    base,
+    name,
+    level,
+    customLevels,
+    levelComparison,
+    mixin,
+    mixinMergeStrategy,
+    useOnlyCustomLevels,
+    formatters,
+    hooks,
+    depthLimit,
+    edgeLimit,
+    onChild,
+    msgPrefix
+  } = opts
+
+  const stringifySafe = configure({
+    maximumDepth: depthLimit,
+    maximumBreadth: edgeLimit
+  })
+
+  const allFormatters = buildFormatters(
+    formatters.level,
+    formatters.bindings,
+    formatters.log
+  )
+
+  const stringifyFn = stringify.bind({
+    [stringifySafeSym]: stringifySafe
+  })
+  const stringifiers = redact ? redaction(redact, stringifyFn) : {}
+  const formatOpts = redact
+    ? { stringify: stringifiers[redactFmtSym] }
+    : { stringify: stringifyFn }
+  const end = '}' + (crlf ? '\r\n' : '\n')
+  const coreChindings = asChindings.bind(null, {
+    [chindingsSym]: '',
+    [serializersSym]: serializers,
+    [stringifiersSym]: stringifiers,
+    [stringifySym]: stringify,
+    [stringifySafeSym]: stringifySafe,
+    [formattersSym]: allFormatters
+  })
+
+  let chindings = ''
+  if (base !== null) {
+    if (name === undefined) {
+      chindings = coreChindings(base)
+    } else {
+      chindings = coreChindings(Object.assign({}, base, { name }))
+    }
+  }
+
+  const time = (timestamp instanceof Function)
+    ? timestamp
+    : (timestamp ? epochTime : nullTime)
+  const timeSliceIndex = time().indexOf(':') + 1
+
+  if (useOnlyCustomLevels && !customLevels) throw Error('customLevels is required if useOnlyCustomLevels is set true')
+  if (mixin && typeof mixin !== 'function') throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`)
+  if (msgPrefix && typeof msgPrefix !== 'string') throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`)
+
+  assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
+  const levels = mappings(customLevels, useOnlyCustomLevels)
+
+  if (typeof stream.emit === 'function') {
+    stream.emit('message', { code: 'PINO_CONFIG', config: { levels, messageKey, errorKey } })
+  }
+
+  assertLevelComparison(levelComparison)
+  const levelCompFunc = genLevelComparison(levelComparison)
+
+  Object.assign(instance, {
+    levels,
+    [levelCompSym]: levelCompFunc,
+    [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
+    [streamSym]: stream,
+    [timeSym]: time,
+    [timeSliceIndexSym]: timeSliceIndex,
+    [stringifySym]: stringify,
+    [stringifySafeSym]: stringifySafe,
+    [stringifiersSym]: stringifiers,
+    [endSym]: end,
+    [formatOptsSym]: formatOpts,
+    [messageKeySym]: messageKey,
+    [errorKeySym]: errorKey,
+    [nestedKeySym]: nestedKey,
+    // protect against injection
+    [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : '',
+    [serializersSym]: serializers,
+    [mixinSym]: mixin,
+    [mixinMergeStrategySym]: mixinMergeStrategy,
+    [chindingsSym]: chindings,
+    [formattersSym]: allFormatters,
+    [hooksSym]: hooks,
+    silent: noop,
+    onChild,
+    [msgPrefixSym]: msgPrefix
+  })
+
+  Object.setPrototypeOf(instance, proto())
+
+  genLsCache(instance)
+
+  instance[setLevelSym](level)
+
+  return instance
+}
+
+module.exports = pino
+
+module.exports.destination = (dest = process.stdout.fd) => {
+  if (typeof dest === 'object') {
+    dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd)
+    return buildSafeSonicBoom(dest)
+  } else {
+    return buildSafeSonicBoom({ dest: normalizeDestFileDescriptor(dest), minLength: 0 })
+  }
+}
+
+module.exports.transport = require('./lib/transport')
+module.exports.multistream = require('./lib/multistream')
+
+module.exports.levels = mappings()
+module.exports.stdSerializers = serializers
+module.exports.stdTimeFunctions = Object.assign({}, time)
+module.exports.symbols = symbols
+module.exports.version = version
+
+// Enables default and name export with TypeScript and Babel
+module.exports.default = pino
+module.exports.pino = pino