Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/usr/local/lib/node_modules/strapi/node_modules/pino/test/   drwxr-xr-x
Free 13.19 GB of 57.97 GB (22.75%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     browser.transmit.test.js (5.78 KB)      -rw-r--r--

'use strict'
var test = require('tape')
var pino = require('../browser')

function noop () {}

test('throws if transmit object does not have send function', function (t) {
  t.throws(function () {
    pino({browser: {transmit: {}}})
  })

  t.throws(function () {
    pino({browser: {transmit: {send: 'not a func'}}})
  })

  t.end()
})

test('calls send function after write', function (t) {
  t.plan(1)
  var c = 0
  var logger = pino({
    browser: {
      write: function (o) {
        c++
      },
      transmit: {
        send: function () {
          t.is(c, 1)
        }
      }
    }
  })

  logger.fatal({test: 'test'})
})

test('passes send function the logged level', function (t) {
  t.plan(1)
  var logger = pino({
    browser: {
      write: function (o) {
      },
      transmit: {
        send: function (level) {
          t.is(level, 'fatal')
        }
      }
    }
  })

  logger.fatal({test: 'test'})
})

test('passes send function messages in logEvent object', function (t) {
  t.plan(2)
  var logger = pino({
    browser: {
      write: noop,
      transmit: {
        send: function (level, logEvent) {
          var messages = logEvent.messages
          t.same(messages[0], {test: 'test'})
          t.is(messages[1], 'another test')
        }
      }
    }
  })

  logger.fatal({test: 'test'}, 'another test')
})

test('supplies a timestamp (ts) in logEvent object which is exactly the same as the `time` property in asObject mode', function (t) {
  t.plan(1)
  var expected
  var logger = pino({
    browser: {
      asObject: true, // implict because `write`, but just to be explicit
      write: function (o) {
        expected = o.time
      },
      transmit: {
        send: function (level, logEvent) {
          t.is(logEvent.ts, expected)
        }
      }
    }
  })

  logger.fatal('test')
})

test('passes send function child bindings via logEvent object', function (t) {
  t.plan(4)
  var logger = pino({
    browser: {
      write: noop,
      transmit: {
        send: function (level, logEvent) {
          var messages = logEvent.messages
          var bindings = logEvent.bindings
          t.same(bindings[0], {first: 'binding'})
          t.same(bindings[1], {second: 'binding2'})
          t.same(messages[0], {test: 'test'})
          t.is(messages[1], 'another test')
        }
      }
    }
  })

  logger
    .child({first: 'binding'})
    .child({second: 'binding2'})
    .fatal({test: 'test'}, 'another test')
})

test('passes send function level:{label, value} via logEvent object', function (t) {
  t.plan(2)
  var logger = pino({
    browser: {
      write: noop,
      transmit: {
        send: function (level, logEvent) {
          var label = logEvent.level.label
          var value = logEvent.level.value

          t.is(label, 'fatal')
          t.is(value, 60)
        }
      }
    }
  })

  logger.fatal({test: 'test'}, 'another test')
})

test('calls send function according to transmit.level', function (t) {
  t.plan(2)
  var c = 0
  var logger = pino({
    browser: {
      write: noop,
      transmit: {
        level: 'error',
        send: function (level) {
          c++
          if (c === 1) t.is(level, 'error')
          if (c === 2) t.is(level, 'fatal')
        }
      }
    }
  })
  logger.warn('ignored')
  logger.error('test')
  logger.fatal('test')
})

test('transmit.level defaults to logger level', function (t) {
  t.plan(2)
  var c = 0
  var logger = pino({
    level: 'error',
    browser: {
      write: noop,
      transmit: {
        send: function (level) {
          c++
          if (c === 1) t.is(level, 'error')
          if (c === 2) t.is(level, 'fatal')
        }
      }
    }
  })
  logger.warn('ignored')
  logger.error('test')
  logger.fatal('test')
})

test('transmit.level is effective even if lower than logger level', function (t) {
  t.plan(3)
  var c = 0
  var logger = pino({
    level: 'error',
    browser: {
      write: noop,
      transmit: {
        level: 'info',
        send: function (level) {
          c++
          if (c === 1) t.is(level, 'warn')
          if (c === 2) t.is(level, 'error')
          if (c === 3) t.is(level, 'fatal')
        }
      }
    }
  })
  logger.warn('ignored')
  logger.error('test')
  logger.fatal('test')
})

test('applies all serializers to messages and bindings (serialize:false - default)', function (t) {
  t.plan(4)
  var logger = pino({
    serializers: {
      first: function () { return 'first' },
      second: function () { return 'second' },
      test: function () { return 'serialize it' }
    },
    browser: {
      write: noop,
      transmit: {
        send: function (level, logEvent) {
          var messages = logEvent.messages
          var bindings = logEvent.bindings
          t.same(bindings[0], {first: 'first'})
          t.same(bindings[1], {second: 'second'})
          t.same(messages[0], {test: 'serialize it'})
          t.is(messages[1].type, 'Error')
        }
      }
    }
  })

  logger
    .child({first: 'binding'})
    .child({second: 'binding2'})
    .fatal({test: 'test'}, Error())
})

test('applies all serializers to messages and bindings (serialize:true)', function (t) {
  t.plan(4)
  var logger = pino({
    serializers: {
      first: function () { return 'first' },
      second: function () { return 'second' },
      test: function () { return 'serialize it' }
    },
    browser: {
      serialize: true,
      write: noop,
      transmit: {
        send: function (level, logEvent) {
          var messages = logEvent.messages
          var bindings = logEvent.bindings
          t.same(bindings[0], {first: 'first'})
          t.same(bindings[1], {second: 'second'})
          t.same(messages[0], {test: 'serialize it'})
          t.is(messages[1].type, 'Error')
        }
      }
    }
  })

  logger
    .child({first: 'binding'})
    .child({second: 'binding2'})
    .fatal({test: 'test'}, Error())
})