mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-23 02:55:13 -04:00
109 lines
3.5 KiB
CoffeeScript
109 lines
3.5 KiB
CoffeeScript
bunyan = require('bunyan')
|
|
|
|
module.exports = Logger =
|
|
initialize: (name) ->
|
|
level = process.env['LOG_LEVEL'] or "debug"
|
|
@logger = bunyan.createLogger
|
|
name: name
|
|
serializers: bunyan.stdSerializers
|
|
level: level
|
|
return @
|
|
|
|
initializeErrorReporting: (sentry_dsn, options) ->
|
|
raven = require "raven"
|
|
@raven = new raven.Client(sentry_dsn, options)
|
|
@lastErrorTimeStamp = 0 # for rate limiting on sentry reporting
|
|
@lastErrorCount = 0
|
|
|
|
captureException: (attributes, message, level) ->
|
|
# handle case of logger.error "message"
|
|
if typeof attributes is 'string'
|
|
attributes = {err: new Error(attributes)}
|
|
# extract any error object
|
|
error = attributes.err or attributes.error
|
|
# avoid reporting errors twice
|
|
for key, value of attributes
|
|
return if value instanceof Error && value.reportedToSentry
|
|
# include our log message in the error report
|
|
if not error?
|
|
error = {message: message} if typeof message is 'string'
|
|
else if message?
|
|
attributes.description = message
|
|
# report the error
|
|
if error?
|
|
# capture attributes and use *_id objects as tags
|
|
tags = {}
|
|
extra = {}
|
|
for key, value of attributes
|
|
tags[key] = value if key.match(/_id/) and typeof value == 'string'
|
|
extra[key] = value
|
|
# capture req object if available
|
|
req = attributes.req
|
|
if req?
|
|
extra.req =
|
|
method: req.method
|
|
url: req.originalUrl
|
|
query: req.query
|
|
headers: req.headers
|
|
ip: req.ip
|
|
# recreate error objects that have been converted to a normal object
|
|
if !(error instanceof Error) and typeof error is "object"
|
|
newError = new Error(error.message)
|
|
for own key, value of error
|
|
newError[key] = value
|
|
error = newError
|
|
# filter paths from the message to avoid duplicate errors in sentry
|
|
# (e.g. errors from `fs` methods which have a path attribute)
|
|
try
|
|
error.message = error.message.replace(" '#{error.path}'", '') if error.path
|
|
# send the error to sentry
|
|
try
|
|
@raven.captureException(error, {tags: tags, extra: extra, level: level})
|
|
# put a flag on the errors to avoid reporting them multiple times
|
|
for key, value of attributes
|
|
value.reportedToSentry = true if value instanceof Error
|
|
catch
|
|
return # ignore any errors
|
|
|
|
debug : () ->
|
|
@logger.debug.apply(@logger, arguments)
|
|
info : ()->
|
|
@logger.info.apply(@logger, arguments)
|
|
log : ()->
|
|
@logger.info.apply(@logger, arguments)
|
|
error: (attributes, message, args...)->
|
|
@logger.error(attributes, message, args...)
|
|
if @raven?
|
|
MAX_ERRORS = 5 # maximum number of errors in 1 minute
|
|
now = new Date()
|
|
# have we recently reported an error?
|
|
recentSentryReport = (now - @lastErrorTimeStamp) < 60 * 1000
|
|
# if so, increment the error count
|
|
if recentSentryReport
|
|
@lastErrorCount++
|
|
else
|
|
@lastErrorCount = 0
|
|
@lastErrorTimeStamp = now
|
|
# only report 5 errors every minute to avoid overload
|
|
if @lastErrorCount < MAX_ERRORS
|
|
# add a note if the rate limit has been hit
|
|
note = if @lastErrorCount+1 is MAX_ERRORS then "(rate limited)" else ""
|
|
# report the exception
|
|
@captureException(attributes, message, "error#{note}")
|
|
err: () ->
|
|
@error.apply(this, arguments)
|
|
warn: ()->
|
|
@logger.warn.apply(@logger, arguments)
|
|
fatal: (attributes, message, callback) ->
|
|
@logger.fatal(attributes, message)
|
|
if @raven?
|
|
cb = (e) -> # call the callback once after 'logged' or 'error' event
|
|
callback()
|
|
cb = () ->
|
|
@captureException(attributes, message, "fatal")
|
|
@raven.once 'logged', cb
|
|
@raven.once 'error', cb
|
|
else
|
|
callback()
|
|
|
|
Logger.initialize("default-sharelatex")
|