/
tools.js
363 lines (328 loc) · 9.85 KB
/
tools.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
'use strict'
/* eslint no-prototype-builtins: 0 */
const format = require('quick-format-unescaped')
const { mapHttpRequest, mapHttpResponse } = require('pino-std-serializers')
const SonicBoom = require('sonic-boom')
const stringifySafe = require('fast-safe-stringify')
const {
lsCacheSym,
chindingsSym,
parsedChindingsSym,
writeSym,
serializersSym,
formatOptsSym,
endSym,
stringifiersSym,
stringifySym,
wildcardFirstSym,
needsMetadataGsym,
wildcardGsym,
redactFmtSym,
streamSym
} = require('./symbols')
function noop () {}
function genLog (z) {
return function LOG (o, ...n) {
if (typeof o === 'object' && o !== null) {
if (o.method && o.headers && o.socket) {
o = mapHttpRequest(o)
} else if (typeof o.setHeader === 'function') {
o = mapHttpResponse(o)
}
this[writeSym](o, format(null, n, this[formatOptsSym]), z)
} else this[writeSym](null, format(o, n, this[formatOptsSym]), z)
}
}
// magically escape strings for json
// relying on their charCodeAt
// everything below 32 needs JSON.stringify()
// 34 and 92 happens all the time, so we
// have a fast case for them
function asString (str) {
var result = ''
var last = 0
var found = false
var point = 255
const l = str.length
if (l > 100) {
return JSON.stringify(str)
}
for (var i = 0; i < l && point >= 32; i++) {
point = str.charCodeAt(i)
if (point === 34 || point === 92) {
result += str.slice(last, i) + '\\'
last = i
found = true
}
}
if (!found) {
result = str
} else {
result += str.slice(last)
}
return point < 32 ? JSON.stringify(str) : '"' + result + '"'
}
function asJson (obj, num, time) {
const stringify = this[stringifySym]
const stringifiers = this[stringifiersSym]
const end = this[endSym]
const chindings = this[chindingsSym]
const serializers = this[serializersSym]
var data = this[lsCacheSym][num] + time
// we need the child bindings added to the output first so instance logged
// objects can take precedence when JSON.parse-ing the resulting log line
data = data + chindings
var value
var notHasOwnProperty = obj.hasOwnProperty === undefined
if (serializers[wildcardGsym]) {
obj = serializers[wildcardGsym](obj)
}
const wildcardStringifier = stringifiers[wildcardFirstSym]
for (var key in obj) {
value = obj[key]
if ((notHasOwnProperty || obj.hasOwnProperty(key)) && value !== undefined) {
value = serializers[key] ? serializers[key](value) : value
const stringifier = stringifiers[key] || wildcardStringifier
switch (typeof value) {
case 'undefined':
case 'function':
continue
case 'number':
/* eslint no-fallthrough: "off" */
if (Number.isFinite(value) === false) {
value = null
}
// this case explicity falls through to the next one
case 'boolean':
if (stringifier) value = stringifier(value)
data += ',"' + key + '":' + value
continue
case 'string':
value = (stringifier || asString)(value)
break
default:
value = (stringifier || stringify)(value)
}
if (value === undefined) continue
data += ',"' + key + '":' + value
}
}
return data + end
}
function asChindings (instance, bindings) {
if (!bindings) {
throw Error('missing bindings for child Pino')
}
var key
var value
var data = instance[chindingsSym]
const stringify = instance[stringifySym]
const stringifiers = instance[stringifiersSym]
const serializers = instance[serializersSym]
if (serializers[wildcardGsym]) {
bindings = serializers[wildcardGsym](bindings)
}
for (key in bindings) {
value = bindings[key]
const valid = key !== 'level' &&
key !== 'serializers' &&
key !== 'customLevels' &&
bindings.hasOwnProperty(key) &&
value !== undefined
if (valid === true) {
value = serializers[key] ? serializers[key](value) : value
value = (stringifiers[key] || stringify)(value)
if (value === undefined) continue
data += ',"' + key + '":' + value
}
}
return data
}
function getPrettyStream (opts, prettifier, dest) {
if (prettifier && typeof prettifier === 'function') {
return prettifierMetaWrapper(prettifier(opts), dest)
}
try {
var prettyFactory = require('pino-pretty')
prettyFactory.asMetaWrapper = prettifierMetaWrapper
return prettifierMetaWrapper(prettyFactory(opts), dest)
} catch (e) {
throw Error('Missing `pino-pretty` module: `pino-pretty` must be installed separately')
}
}
function prettifierMetaWrapper (pretty, dest) {
var warned = false
return {
[needsMetadataGsym]: true,
lastLevel: 0,
lastMsg: null,
lastObj: null,
lastLogger: null,
flushSync () {
if (warned) {
return
}
warned = true
dest.write(pretty(Object.assign({
level: 40, // warn
msg: 'pino.final with prettyPrint does not support flushing',
time: Date.now()
}, this.chindings())))
},
chindings () {
const lastLogger = this.lastLogger
var chindings = null
// protection against flushSync being called before logging
// anything
if (!lastLogger) {
return null
}
if (lastLogger.hasOwnProperty(parsedChindingsSym)) {
chindings = lastLogger[parsedChindingsSym]
} else {
chindings = JSON.parse('{"v":1' + lastLogger[chindingsSym] + '}')
lastLogger[parsedChindingsSym] = chindings
}
return chindings
},
write (chunk) {
const lastLogger = this.lastLogger
const chindings = this.chindings()
var time = this.lastTime
if (time.match(/^\d+/)) {
time = parseInt(time)
}
var lastObj = this.lastObj
var errorProps = null
const obj = Object.assign({
level: this.lastLevel,
time
}, chindings, lastObj, errorProps)
const serializers = lastLogger[serializersSym]
const keys = Object.keys(serializers)
var key
for (var i = 0; i < keys.length; i++) {
key = keys[i]
if (obj[key] !== undefined) {
obj[key] = serializers[key](obj[key])
}
}
const stringifiers = lastLogger[stringifiersSym]
const redact = stringifiers[redactFmtSym]
const formatted = pretty(typeof redact === 'function' ? redact(obj) : obj)
if (formatted === undefined) return
dest.write(formatted)
}
}
}
function hasBeenTampered (stream) {
return stream.write !== stream.constructor.prototype.write
}
function buildSafeSonicBoom (dest, buffer = 0, sync = true) {
const stream = new SonicBoom(dest, buffer, sync)
stream.on('error', filterBrokenPipe)
return stream
function filterBrokenPipe (err) {
// TODO verify on Windows
if (err.code === 'EPIPE') {
// If we get EPIPE, we should stop logging here
// however we have no control to the consumer of
// SonicBoom, so we just overwrite the write method
stream.write = noop
stream.end = noop
stream.flushSync = noop
stream.destroy = noop
return
}
stream.removeListener('error', filterBrokenPipe)
stream.emit('error', err)
}
}
function createArgsNormalizer (defaultOptions) {
return function normalizeArgs (opts = {}, stream) {
// support stream as a string
if (typeof opts === 'string') {
stream = buildSafeSonicBoom(opts)
opts = {}
} else if (typeof stream === 'string') {
stream = buildSafeSonicBoom(stream)
} else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
stream = opts
opts = null
}
opts = Object.assign({}, defaultOptions, opts)
if ('extreme' in opts) {
throw Error('The extreme option has been removed, use pino.extreme instead')
}
if ('onTerminated' in opts) {
throw Error('The onTerminated option has been removed, use pino.final instead')
}
const { enabled, prettyPrint, prettifier, messageKey } = opts
if (enabled === false) opts.level = 'silent'
stream = stream || process.stdout
if (stream === process.stdout && stream.fd >= 0 && !hasBeenTampered(stream)) {
stream = buildSafeSonicBoom(stream.fd)
}
if (prettyPrint) {
const prettyOpts = Object.assign({ messageKey }, prettyPrint)
stream = getPrettyStream(prettyOpts, prettifier, stream)
}
return { opts, stream }
}
}
function final (logger, handler) {
if (typeof logger === 'undefined' || typeof logger.child !== 'function') {
throw Error('expected a pino logger instance')
}
const hasHandler = (typeof handler !== 'undefined')
if (hasHandler && typeof handler !== 'function') {
throw Error('if supplied, the handler parameter should be a function')
}
const stream = logger[streamSym]
if (typeof stream.flushSync !== 'function') {
throw Error('final requires a stream that has a flushSync method, such as pino.destination and pino.extreme')
}
const finalLogger = new Proxy(logger, {
get: (logger, key) => {
if (key in logger.levels.values) {
return (...args) => {
logger[key](...args)
stream.flushSync()
}
}
return logger[key]
}
})
if (!hasHandler) {
return finalLogger
}
return (err = null, ...args) => {
try {
stream.flushSync()
} catch (e) {
// it's too late to wait for the stream to be ready
// because this is a final tick scenario.
// in practice there shouldn't be a situation where it isn't
// however, swallow the error just in case (and for easier testing)
}
return handler(err, finalLogger, ...args)
}
}
function stringify (obj) {
try {
return JSON.stringify(obj)
} catch (_) {
return stringifySafe(obj)
}
}
module.exports = {
noop,
buildSafeSonicBoom,
getPrettyStream,
asChindings,
asJson,
genLog,
createArgsNormalizer,
final,
stringify
}