def configure_raven(app):
if 'SENTRY_DSN' in os.environ:
import raven
from raven.contrib.flask import Sentry
raven.load(os.environ['SENTRY_DSN'], app.config)
return Sentry(app)
def __init__(self, dsn_file):
try:
loaded = unserialize_yaml(dsn_file, critical=True)
sentry_dsn = loaded["dsn"]
self._sentry_dsn = sentry_dsn
logger.debug("sentry_dsn: %s", sentry_dsn)
except IOError as err:
logger.error(
"Sentry monitoring DSN file %s does not exist"
"or is unreadable. Error: %s",
dsn_file, err)
raise nagiosplugin.CheckError(
"Invalid sentry monitoring DSN file: {}".format(dsn_file))
dsn_parsed = raven.load(sentry_dsn)
self._public_key = dsn_parsed["SENTRY_PUBLIC_KEY"]
self._secret_key = dsn_parsed["SENTRY_SECRET_KEY"]
transport_options = dsn_parsed["SENTRY_TRANSPORT_OPTIONS"]
self._verify_ssl = False if ("verify_ssl" in transport_options
and transport_options["verify_ssl"] == "0"
) else True
# API format: GET /api/0/projects/{project_id}/groups/
server = dsn_parsed["SENTRY_SERVERS"][0]
project_id = dsn_parsed["SENTRY_PROJECT"]
parsed = urlparse.urlparse(server)
self._url = urlparse.urlunparse((
parsed.scheme,
parsed.netloc,
"/api/0/projects/{}/groups/".format(project_id),
parsed.params,
parsed.query,
parsed.fragment,
))
def __init__(self, dsn_file):
try:
loaded = unserialize_yaml(dsn_file, critical=True)
sentry_dsn = loaded["dsn"]
self._sentry_dsn = sentry_dsn
logger.debug("sentry_dsn: %s", sentry_dsn)
except IOError as err:
logger.error(
"Sentry monitoring DSN file %s does not exist"
"or is unreadable. Error: %s", dsn_file, err)
raise nagiosplugin.CheckError(
"Invalid sentry monitoring DSN file: {}".format(dsn_file))
dsn_parsed = raven.load(sentry_dsn)
self._public_key = dsn_parsed["SENTRY_PUBLIC_KEY"]
self._secret_key = dsn_parsed["SENTRY_SECRET_KEY"]
transport_options = dsn_parsed["SENTRY_TRANSPORT_OPTIONS"]
self._verify_ssl = False if (
"verify_ssl" in transport_options
and transport_options["verify_ssl"] == "0") else True
# API format: GET /api/0/projects/{project_id}/groups/
server = dsn_parsed["SENTRY_SERVERS"][0]
project_id = dsn_parsed["SENTRY_PROJECT"]
parsed = urlparse.urlparse(server)
self._url = urlparse.urlunparse((
parsed.scheme,
parsed.netloc,
"/api/0/projects/{}/groups/".format(project_id),
parsed.params,
parsed.query,
parsed.fragment,
))
def __init__(self, dsn=None, **options):
o = options
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger('%s.%s' % (cls.__module__,
cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.debug(msg)
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
urlparts = urlparse(dsn)
msg = "Configuring Raven for host: %s://%s:%s" % (urlparts.scheme,
urlparts.netloc, urlparts.path)
self.logger.debug(msg)
dsn_config = raven.load(dsn, transport_registry=self._registry)
servers = dsn_config['SENTRY_SERVERS']
project = dsn_config['SENTRY_PROJECT']
public_key = dsn_config['SENTRY_PUBLIC_KEY']
secret_key = dsn_config['SENTRY_SECRET_KEY']
else:
servers = o.get('servers')
project = o.get('project')
public_key = o.get('public_key')
secret_key = o.get('secret_key')
self.servers = servers
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.include_paths = set(o.get('include_paths') or [])
self.exclude_paths = set(o.get('exclude_paths') or [])
self.name = unicode(o.get('name') or defaults.NAME)
self.auto_log_stacks = bool(o.get('auto_log_stacks') or
defaults.AUTO_LOG_STACKS)
self.string_max_length = int(o.get('string_max_length') or
defaults.MAX_LENGTH_STRING)
self.list_max_length = int(o.get('list_max_length') or defaults.MAX_LENGTH_LIST)
self.site = o.get('site', defaults.SITE)
self.processors = o.get('processors')
if self.processors is None:
self.processors = defaults.PROCESSORS
context = o.get('context')
if context is None:
context = {'sys.argv': sys.argv[:]}
self.extra = context
self.module_cache = ModuleProxyCache()
# servers may be set to a NoneType (for Django)
if not self.is_enabled():
self.logger.info('Raven is not configured (disabled). Please see documentation for more information.')
def configure_heroku(app):
import os
import traceback
if 'SENTRY_DSN' in os.environ:
try:
import raven
from raven.contrib.flask import Sentry
raven.load(os.environ['SENTRY_DSN'], app.config)
sentry = Sentry(app)
return sentry
except Exception, e:
print "Unexpected error:", e
traceback.print_exc()
if 'MEMCACHE_SERVERS' in os.environ:
mc = dict(servers=[os.environ.get('MEMCACHE_SERVERS')],
username=os.environ.get('MEMCACHE_USERNAME'),
password=os.environ.get('MEMCACHE_PASSWORD'),
binary=True)
def __init__(self, servers=None, include_paths=None, exclude_paths=None, timeout=None,
name=None, auto_log_stacks=None, key=None, string_max_length=None,
list_max_length=None, site=None, public_key=None, secret_key=None,
processors=None, project=None, dsn=None, **kwargs):
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger('%s.%s' % (cls.__module__, cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if isinstance(servers, basestring):
# must be a DSN:
if dsn:
raise ValueError("You seem to be incorrectly instantiating the raven Client class.")
dsn = servers
servers = None
if dsn is None and os.environ.get('SENTRY_DSN'):
self.logger.info("Configuring Raven from environment variable 'SENTRY_DSN'")
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
urlparts = urlparse(dsn)
self.logger.info("Configuring Raven for host: %s://%s:%s", urlparts.scheme, urlparts.netloc, urlparts.path)
options = raven.load(dsn)
servers = options['SENTRY_SERVERS']
project = options['SENTRY_PROJECT']
public_key = options['SENTRY_PUBLIC_KEY']
secret_key = options['SENTRY_SECRET_KEY']
# servers may be set to a NoneType (for Django)
if servers and not (key or (secret_key and public_key)):
raise TypeError('Missing configuration for client. Please see documentation.')
self.servers = servers
self.include_paths = set(include_paths or defaults.INCLUDE_PATHS)
self.exclude_paths = set(exclude_paths or defaults.EXCLUDE_PATHS)
self.timeout = int(timeout or defaults.TIMEOUT)
self.name = unicode(name or defaults.NAME)
self.auto_log_stacks = bool(auto_log_stacks or defaults.AUTO_LOG_STACKS)
self.key = str(key or defaults.KEY)
self.string_max_length = int(string_max_length or defaults.MAX_LENGTH_STRING)
self.list_max_length = int(list_max_length or defaults.MAX_LENGTH_LIST)
if (site or defaults.SITE):
self.site = unicode(site or defaults.SITE)
else:
self.site = None
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.processors = processors or defaults.PROCESSORS
self.module_cache = ModuleProxyCache()
self.udp_socket = None
def configure_heroku(app):
import os
import traceback
if 'SENTRY_DSN' in os.environ:
try:
import raven
from raven.contrib.flask import Sentry
raven.load(os.environ['SENTRY_DSN'], app.config)
sentry = Sentry(app)
return sentry
except Exception, e:
print "Unexpected error:", e
traceback.print_exc()
if 'MEMCACHE_SERVERS' in os.environ:
mc = dict(
servers=[os.environ.get('MEMCACHE_SERVERS')],
username=os.environ.get('MEMCACHE_USERNAME'),
password=os.environ.get('MEMCACHE_PASSWORD'),
binary=True)
def __init__(self, servers=None, include_paths=None, exclude_paths=None, timeout=None,
name=None, auto_log_stacks=None, key=None, string_max_length=None,
list_max_length=None, site=None, public_key=None, secret_key=None,
processors=None, project=None, dsn=None, **kwargs):
if isinstance(servers, basestring):
# must be a DSN:
if dsn:
raise ValueError("You seem to be incorrectly instantiating the raven Client class.")
dsn = servers
servers = None
if dsn is None and os.environ.get('SENTRY_DSN'):
self.logger.info("Configuring Raven from environment variable 'SENTRY_DSN'")
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
self.logger.info("Configuring Raven from DSN: %r", dsn)
options = raven.load(dsn)
servers = options['SENTRY_SERVERS']
project = options['SENTRY_PROJECT']
public_key = options['SENTRY_PUBLIC_KEY']
secret_key = options['SENTRY_SECRET_KEY']
# servers may be set to a NoneType (for Django)
if servers and not (key or (secret_key and public_key)):
raise TypeError('Missing configuration for client. Please see documentation.')
self.servers = servers
self.include_paths = set(include_paths or defaults.INCLUDE_PATHS)
self.exclude_paths = set(exclude_paths or defaults.EXCLUDE_PATHS)
self.timeout = int(timeout or defaults.TIMEOUT)
self.name = unicode(name or defaults.NAME)
self.auto_log_stacks = bool(auto_log_stacks or defaults.AUTO_LOG_STACKS)
self.key = str(key or defaults.KEY)
self.string_max_length = int(string_max_length or defaults.MAX_LENGTH_STRING)
self.list_max_length = int(list_max_length or defaults.MAX_LENGTH_LIST)
if (site or defaults.SITE):
self.site = unicode(site or defaults.SITE)
else:
self.site = None
self.public_key = public_key
self.secret_key = secret_key
self.project = int(project or defaults.PROJECT)
self.processors = processors or defaults.PROCESSORS
self.logger = logging.getLogger(__name__)
self.module_cache = ModuleProxyCache()
self.udp_socket = None
def set_dsn(self, dsn=None, **options):
o = options
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.debug(msg)
dsn = os.environ['SENTRY_DSN']
try:
servers, public_key, secret_key, project, transport_options = self.dsns[
dsn]
except KeyError:
if dsn:
# TODO: should we validate other options weren't sent?
urlparts = urlparse(dsn)
self.logger.debug(
"Configuring Raven for host: %s://%s:%s" %
(urlparts.scheme, urlparts.netloc, urlparts.path))
dsn_config = raven.load(dsn, transport_registry=self._registry)
servers = dsn_config['SENTRY_SERVERS']
project = dsn_config['SENTRY_PROJECT']
public_key = dsn_config['SENTRY_PUBLIC_KEY']
secret_key = dsn_config['SENTRY_SECRET_KEY']
transport_options = dsn_config.get('SENTRY_TRANSPORT_OPTIONS',
{})
else:
if o.get('servers'):
warnings.warn(
'Manually configured connections are deprecated. Switch to a DSN.',
DeprecationWarning)
servers = o.get('servers')
project = o.get('project')
public_key = o.get('public_key')
secret_key = o.get('secret_key')
transport_options = {}
self.dsns[
dsn] = servers, public_key, secret_key, project, transport_options
self.servers = servers
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.transport_options = transport_options
def __init__(self, servers=None, include_paths=None, exclude_paths=None, timeout=None,
name=None, auto_log_stacks=None, key=None, string_max_length=None,
list_max_length=None, site=None, public_key=None, secret_key=None,
processors=None, project=None, dsn=None, **kwargs):
if dsn is None and os.environ.get('SENTRY_DSN'):
self.logger.info("Configuring Raven from environment variable 'SENTRY_DSN'")
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
self.logger.info("Configuring Raven from DSN: %r", dsn)
options = raven.load(dsn)
servers = [options['SENTRY_SERVERS']]
project = options['SENTRY_PROJECT']
public_key = options['PUBLIC_KEY']
secret_key = options['SECRET_KEY']
# servers may be set to a NoneType (for Django)
if servers and not (key or (secret_key and public_key)):
raise TypeError('Missing configuration for client. Please see documentation.')
self.servers = servers
self.include_paths = set(include_paths or defaults.INCLUDE_PATHS)
self.exclude_paths = set(exclude_paths or defaults.EXCLUDE_PATHS)
self.timeout = int(timeout or defaults.TIMEOUT)
self.name = unicode(name or defaults.NAME)
self.auto_log_stacks = bool(auto_log_stacks or defaults.AUTO_LOG_STACKS)
self.key = str(key or defaults.KEY)
self.string_max_length = int(string_max_length or defaults.MAX_LENGTH_STRING)
self.list_max_length = int(list_max_length or defaults.MAX_LENGTH_LIST)
if (site or defaults.SITE):
self.site = unicode(site or defaults.SITE)
else:
self.site = None
self.public_key = public_key
self.secret_key = secret_key
self.project = int(project or defaults.PROJECT)
self.processors = processors or defaults.PROCESSORS
self.logger = logging.getLogger(__name__)
self.module_cache = ModuleProxyCache()
self.udp_socket = None
def set_dsn(self, dsn=None, **options):
o = options
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.debug(msg)
dsn = os.environ['SENTRY_DSN']
try:
servers, public_key, secret_key, project, transport_options = self.dsns[dsn]
except KeyError:
if dsn:
# TODO: should we validate other options weren't sent?
urlparts = urlparse(dsn)
self.logger.debug(
"Configuring Raven for host: %s://%s:%s" % (urlparts.scheme,
urlparts.netloc, urlparts.path))
dsn_config = raven.load(dsn, transport_registry=self._registry)
servers = dsn_config['SENTRY_SERVERS']
project = dsn_config['SENTRY_PROJECT']
public_key = dsn_config['SENTRY_PUBLIC_KEY']
secret_key = dsn_config['SENTRY_SECRET_KEY']
transport_options = dsn_config.get('SENTRY_TRANSPORT_OPTIONS', {})
else:
if o.get('servers'):
warnings.warn('Manually configured connections are deprecated. Switch to a DSN.', DeprecationWarning)
servers = o.get('servers')
project = o.get('project')
public_key = o.get('public_key')
secret_key = o.get('secret_key')
transport_options = {}
self.dsns[dsn] = servers, public_key, secret_key, project, transport_options
self.servers = servers
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.transport_options = transport_options
def setup_handlers():
if 'sentry_handler' not in __opts__:
log.debug('No \'sentry_handler\' key was found in the configuration')
return False
options = {}
dsn = get_config_value('dsn')
if dsn is not None:
try:
dsn_config = raven.load(dsn)
options.update({
'project': dsn_config['SENTRY_PROJECT'],
'servers': dsn_config['SENTRY_SERVERS'],
'public_key': dsn_config['SENTRY_PUBLIC_KEY'],
'secret_key': dsn_config['SENTRY_SECRET_KEY']
})
except ValueError as exc:
log.info(
'Raven failed to parse the configuration provided '
'DSN: {0}'.format(exc)
)
# Allow options to be overridden if previously parsed, or define them
for key in ('project', 'servers', 'public_key', 'secret_key'):
config_value = get_config_value(key)
if config_value is None and key not in options:
log.debug(
'The required \'sentry_handler\' configuration key, '
'{0!r}, is not properly configured. Not configuring '
'the sentry logging handler.'.format(key)
)
return
elif config_value is None:
continue
options[key] = config_value
# site: An optional, arbitrary string to identify this client installation.
options.update({
# site: An optional, arbitrary string to identify this client
# installation
'site': get_config_value('site'),
# name: This will override the server_name value for this installation.
# Defaults to socket.gethostname()
'name': get_config_value('name'),
# exclude_paths: Extending this allow you to ignore module prefixes
# when sentry attempts to discover which function an error comes from
'exclude_paths': get_config_value('exclude_paths', ()),
# include_paths: For example, in Django this defaults to your list of
# INSTALLED_APPS, and is used for drilling down where an exception is
# located
'include_paths': get_config_value('include_paths', ()),
# list_max_length: The maximum number of items a list-like container
# should store.
'list_max_length': get_config_value('list_max_length'),
# string_max_length: The maximum characters of a string that should be
# stored.
'string_max_length': get_config_value('string_max_length'),
# auto_log_stacks: Should Raven automatically log frame stacks
# (including locals) all calls as it would for exceptions.
'auto_log_stacks': get_config_value('auto_log_stacks'),
# timeout: If supported, the timeout value for sending messages to
# remote.
'timeout': get_config_value('timeout', 1),
# processors: A list of processors to apply to events before sending
# them to the Sentry server. Useful for sending additional global state
# data or sanitizing data that you want to keep off of the server.
'processors': get_config_value('processors'),
# dsn: Ensure the DSN is passed into the client
'dsn': dsn
})
client = raven.Client(**options)
try:
handler = SentryHandler(client)
handler.setLevel(LOG_LEVELS[get_config_value('log_level', 'error')])
return handler
except ValueError as exc:
log.debug(
'Failed to setup the sentry logging handler: {0}'.format(exc),
exc_info=exc
)
def __init__(self,
servers=None,
include_paths=None,
exclude_paths=None,
timeout=None,
name=None,
auto_log_stacks=None,
key=None,
string_max_length=None,
list_max_length=None,
site=None,
public_key=None,
secret_key=None,
processors=None,
project=None,
dsn=None,
**kwargs):
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger('%s.%s' %
(cls.__module__, cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if isinstance(servers, basestring):
# must be a DSN:
if dsn:
# TODO: this should indicate what the caller can do to correct
# the constructor
msg = "You seem to be incorrectly instantiating the " + \
"raven Client class"
raise ValueError(msg)
dsn = servers
servers = None
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.info(msg)
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
urlparts = urlparse(dsn)
msg = "Configuring Raven for host: %s://%s:%s" % (
urlparts.scheme, urlparts.netloc, urlparts.path)
self.logger.info(msg)
options = raven.load(dsn, transport_registry=self._registry)
servers = options['SENTRY_SERVERS']
project = options['SENTRY_PROJECT']
public_key = options['SENTRY_PUBLIC_KEY']
secret_key = options['SENTRY_SECRET_KEY']
# servers may be set to a NoneType (for Django)
if servers and not (key or (secret_key and public_key)):
msg = 'Missing configuration for client. Please see documentation.'
raise TypeError(msg)
self.servers = servers
self.include_paths = set(include_paths or defaults.INCLUDE_PATHS)
self.exclude_paths = set(exclude_paths or defaults.EXCLUDE_PATHS)
self.timeout = int(timeout or defaults.TIMEOUT)
self.name = unicode(name or defaults.NAME)
self.auto_log_stacks = bool(auto_log_stacks
or defaults.AUTO_LOG_STACKS)
self.key = str(key or defaults.KEY)
self.string_max_length = int(string_max_length
or defaults.MAX_LENGTH_STRING)
self.list_max_length = int(list_max_length or defaults.MAX_LENGTH_LIST)
if (site or defaults.SITE):
self.site = unicode(site or defaults.SITE)
else:
self.site = None
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.processors = processors or defaults.PROCESSORS
self.module_cache = ModuleProxyCache()
def __init__(self, dsn=None, raise_send_errors=False, **options):
global Raven
o = options
self.configure_logging()
self.raise_send_errors = raise_send_errors
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger(
'%s.%s' % (cls.__module__, cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.debug(msg)
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options weren't sent?
urlparts = urlparse(dsn)
self.logger.debug(
"Configuring Raven for host: %s://%s:%s" % (urlparts.scheme,
urlparts.netloc, urlparts.path))
dsn_config = raven.load(dsn, transport_registry=self._registry)
servers = dsn_config['SENTRY_SERVERS']
project = dsn_config['SENTRY_PROJECT']
public_key = dsn_config['SENTRY_PUBLIC_KEY']
secret_key = dsn_config['SENTRY_SECRET_KEY']
transport_options = dsn_config.get('SENTRY_TRANSPORT_OPTIONS', {})
else:
if o.get('servers'):
warnings.warn('Manually configured connections are deprecated. Switch to a DSN.', DeprecationWarning)
servers = o.get('servers')
project = o.get('project')
public_key = o.get('public_key')
secret_key = o.get('secret_key')
transport_options = {}
self.servers = servers
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.transport_options = transport_options
self.include_paths = set(o.get('include_paths') or [])
self.exclude_paths = set(o.get('exclude_paths') or [])
self.name = six.text_type(o.get('name') or defaults.NAME)
self.auto_log_stacks = bool(
o.get('auto_log_stacks') or defaults.AUTO_LOG_STACKS)
self.capture_locals = bool(
o.get('capture_locals', defaults.CAPTURE_LOCALS))
self.string_max_length = int(
o.get('string_max_length') or defaults.MAX_LENGTH_STRING)
self.list_max_length = int(
o.get('list_max_length') or defaults.MAX_LENGTH_LIST)
self.site = o.get('site', defaults.SITE)
self.include_versions = o.get('include_versions', True)
self.processors = o.get('processors')
if self.processors is None:
self.processors = defaults.PROCESSORS
context = o.get('context')
if context is None:
context = {'sys.argv': sys.argv[:]}
self.extra = context
self.tags = o.get('tags') or {}
self.module_cache = ModuleProxyCache()
# servers may be set to a NoneType (for Django)
if not self.is_enabled():
self.logger.info(
'Raven is not configured (logging is disabled). Please see the'
' documentation for more information.')
if Raven is None:
Raven = self
self._context = Context()
def __init__(self, servers=None, include_paths=None, exclude_paths=None,
name=None, auto_log_stacks=None, key=None,
string_max_length=None, list_max_length=None, site=None,
public_key=None, secret_key=None, processors=None, project=None,
dsn=None, **kwargs):
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger('%s.%s' % (cls.__module__,
cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if isinstance(servers, basestring):
# must be a DSN:
if dsn:
# TODO: this should indicate what the caller can do to correct
# the constructor
msg = "You seem to be incorrectly instantiating the " + \
"raven Client class"
raise ValueError(msg)
dsn = servers
servers = None
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.info(msg)
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
urlparts = urlparse(dsn)
msg = "Configuring Raven for host: %s://%s:%s" % (
urlparts.scheme, urlparts.netloc, urlparts.path)
self.logger.info(msg)
options = raven.load(dsn, transport_registry=self._registry)
servers = options['SENTRY_SERVERS']
project = options['SENTRY_PROJECT']
public_key = options['SENTRY_PUBLIC_KEY']
secret_key = options['SENTRY_SECRET_KEY']
# servers may be set to a NoneType (for Django)
if servers and not (key or (secret_key and public_key)):
self.logger.info('Raven is not configured (disabled). Please see documentation for more information.')
if kwargs.get('timeout') is not None:
warnings.warn('The ``timeout`` option no longer does anything. Pass the option to your transport instead.')
self.servers = servers
self.include_paths = set(include_paths or defaults.INCLUDE_PATHS)
self.exclude_paths = set(exclude_paths or defaults.EXCLUDE_PATHS)
self.name = unicode(name or defaults.NAME)
self.auto_log_stacks = bool(auto_log_stacks or
defaults.AUTO_LOG_STACKS)
self.key = str(key or defaults.KEY)
self.string_max_length = int(string_max_length or
defaults.MAX_LENGTH_STRING)
self.list_max_length = int(list_max_length or defaults.MAX_LENGTH_LIST)
if (site or defaults.SITE):
self.site = unicode(site or defaults.SITE)
else:
self.site = None
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.processors = processors or defaults.PROCESSORS
self.module_cache = ModuleProxyCache()
'gmail.com', 'hotmail.com', 'live.com', 'msn.com', 'yahoo.com',
'googlemail.com', 'facebookmail.com'
]
MAIL_SERVER = 'smtp.sendgrid.net'
MAIL_PORT = 25
MAIL_USERNAME = os.environ.get('SENDGRID_USERNAME')
MAIL_PASSWORD = os.environ.get('SENDGRID_PASSWORD')
MAIL_USE_TLS = True
MAIL_DOMAIN = os.environ.get('SENDGRID_DOMAIN', 'codebox.cc')
DEFAULT_MAIL_SENDER = '*****@*****.**'
if os.environ.has_key('SENTRY_DSN'):
try:
import raven
raven.load(os.environ['SENTRY_DSN'], Config.__dict__)
except:
print "Unexpected error:", sys.exc_info()
if os.environ.has_key('REDISTOGO_URL'):
# 'redis://*****:*****@my.host:6789'
urlparse.uses_netloc.append('redis')
url = urlparse.urlparse(os.environ['REDISTOGO_URL'])
Config.REDIS_PASSWORD = url.password
Config.REDIS_HOST = url.hostname
Config.REDIS_PORT = url.port
class TestingConfig(Config):
REDIS_DB = 9
TESTING = True
SECRET_KEY = os.environ.get('SECRET_KEY', '\x89\x1d\xec\x8eJ\xda=C`\xf3<X\x81\xff\x1e\r{+\x1b\xe1\xd1@ku')
REDIS_DB = 0
JANRAIN_API_KEY = os.environ.get('JANRAIN_API_KEY')
DOMAIN_BLACKLIST = ['gmail.com', 'hotmail.com', 'live.com', 'msn.com', 'yahoo.com', 'googlemail.com', 'facebookmail.com']
MAIL_SERVER = 'smtp.sendgrid.net'
MAIL_PORT = 25
MAIL_USERNAME = os.environ.get('SENDGRID_USERNAME')
MAIL_PASSWORD = os.environ.get('SENDGRID_PASSWORD')
MAIL_USE_TLS = True
MAIL_DOMAIN = os.environ.get('SENDGRID_DOMAIN', 'codebox.cc')
DEFAULT_MAIL_SENDER = '*****@*****.**'
if os.environ.has_key('SENTRY_DSN'):
try:
import raven
raven.load(os.environ['SENTRY_DSN'], Config.__dict__)
except:
print "Unexpected error:", sys.exc_info()
if os.environ.has_key('REDISTOGO_URL'):
# 'redis://*****:*****@my.host:6789'
urlparse.uses_netloc.append('redis')
url = urlparse.urlparse(os.environ['REDISTOGO_URL'])
Config.REDIS_PASSWORD = url.password
Config.REDIS_HOST = url.hostname
Config.REDIS_PORT = url.port
class TestingConfig(Config):
REDIS_DB = 9
TESTING = True
def __init__(self, dsn=None, **options):
global Raven
o = options
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger('%s.%s' % (cls.__module__,
cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.debug(msg)
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
urlparts = urlparse(dsn)
msg = "Configuring Raven for host: %s://%s:%s" % (urlparts.scheme,
urlparts.netloc, urlparts.path)
self.logger.debug(msg)
dsn_config = raven.load(dsn, transport_registry=self._registry)
servers = dsn_config['SENTRY_SERVERS']
project = dsn_config['SENTRY_PROJECT']
public_key = dsn_config['SENTRY_PUBLIC_KEY']
secret_key = dsn_config['SENTRY_SECRET_KEY']
else:
servers = o.get('servers')
project = o.get('project')
public_key = o.get('public_key')
secret_key = o.get('secret_key')
self.servers = servers
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.include_paths = set(o.get('include_paths') or [])
self.exclude_paths = set(o.get('exclude_paths') or [])
self.name = unicode(o.get('name') or defaults.NAME)
self.auto_log_stacks = bool(o.get('auto_log_stacks') or
defaults.AUTO_LOG_STACKS)
self.string_max_length = int(o.get('string_max_length') or
defaults.MAX_LENGTH_STRING)
self.list_max_length = int(o.get('list_max_length') or defaults.MAX_LENGTH_LIST)
self.site = o.get('site', defaults.SITE)
self.include_versions = o.get('include_versions', True)
self.processors = o.get('processors')
if self.processors is None:
self.processors = defaults.PROCESSORS
context = o.get('context')
if context is None:
context = {'sys.argv': sys.argv[:]}
self.extra = context
self.module_cache = ModuleProxyCache()
# servers may be set to a NoneType (for Django)
if not self.is_enabled():
self.logger.info('Raven is not configured (disabled). Please see documentation for more information.')
if Raven is None:
Raven = self
def setup_handlers():
if 'sentry_handler' not in __opts__:
log.debug('No \'sentry_handler\' key was found in the configuration')
return False
options = {}
dsn = get_config_value('dsn')
if dsn is not None:
try:
dsn_config = raven.load(dsn)
options.update({
'project': dsn_config['SENTRY_PROJECT'],
'servers': dsn_config['SENTRY_SERVERS'],
'public_key': dsn_config['SENTRY_PUBLIC_KEY'],
'private_key': dsn_config['SENTRY_SECRET_KEY']
})
except ValueError as exc:
log.info('Raven failed to parse the configuration provided '
'DSN: {0}'.format(exc))
# Allow options to be overridden if previously parsed, or define them
for key in ('project', 'servers', 'public_key', 'private_key'):
config_value = get_config_value(key)
if config_value is None and key not in options:
log.debug('The required \'sentry_handler\' configuration key, '
'{0!r}, is not properly configured. Not configuring '
'the sentry logging handler.'.format(key))
return
elif config_value is None:
continue
options[key] = config_value
# site: An optional, arbitrary string to identify this client installation.
options.update({
# site: An optional, arbitrary string to identify this client
# installation
'site': get_config_value('site'),
# name: This will override the server_name value for this installation.
# Defaults to socket.gethostname()
'name': get_config_value('name'),
# exclude_paths: Extending this allow you to ignore module prefixes
# when sentry attempts to discover which function an error comes from
'exclude_paths': get_config_value('exclude_paths', ()),
# include_paths: For example, in Django this defaults to your list of
# INSTALLED_APPS, and is used for drilling down where an exception is
# located
'include_paths': get_config_value('include_paths', ()),
# list_max_length: The maximum number of items a list-like container
# should store.
'list_max_length': get_config_value('list_max_length'),
# string_max_length: The maximum characters of a string that should be
# stored.
'string_max_length': get_config_value('string_max_length'),
# auto_log_stacks: Should Raven automatically log frame stacks
# (including locals) all calls as it would for exceptions.
'auto_log_stacks': get_config_value('auto_log_stacks'),
# timeout: If supported, the timeout value for sending messages to
# remote.
'timeout': get_config_value('timeout', 1),
# processors: A list of processors to apply to events before sending
# them to the Sentry server. Useful for sending additional global state
# data or sanitizing data that you want to keep off of the server.
'processors': get_config_value('processors'),
# dsn: Ensure the DSN is passed into the client
'dsn': dsn
})
client = raven.Client(**options)
try:
handler = SentryHandler(client)
handler.setLevel(LOG_LEVELS[get_config_value('log_level', 'error')])
return handler
except ValueError as exc:
log.debug(
'Failed to setup the sentry logging handler: {0}'.format(exc),
exc_info=exc)
def __init__(self, dsn=None, **options):
global Raven
o = options
self.configure_logging()
# configure loggers first
cls = self.__class__
self.state = ClientState()
self.logger = logging.getLogger(
'%s.%s' % (cls.__module__, cls.__name__))
self.error_logger = logging.getLogger('sentry.errors')
if dsn is None and os.environ.get('SENTRY_DSN'):
msg = "Configuring Raven from environment variable 'SENTRY_DSN'"
self.logger.debug(msg)
dsn = os.environ['SENTRY_DSN']
if dsn:
# TODO: should we validate other options werent sent?
urlparts = urlparse(dsn)
self.logger.debug(
"Configuring Raven for host: %s://%s:%s" % (urlparts.scheme,
urlparts.netloc, urlparts.path))
dsn_config = raven.load(dsn, transport_registry=self._registry)
servers = dsn_config['SENTRY_SERVERS']
project = dsn_config['SENTRY_PROJECT']
public_key = dsn_config['SENTRY_PUBLIC_KEY']
secret_key = dsn_config['SENTRY_SECRET_KEY']
transport_options = dsn_config.get('SENTRY_TRANSPORT_OPTIONS', {})
else:
if o.get('servers'):
warnings.warn('Manually configured connections are deprecated. Switch to a DSN.', DeprecationWarning)
servers = o.get('servers')
project = o.get('project')
public_key = o.get('public_key')
secret_key = o.get('secret_key')
transport_options = {}
self.servers = servers
self.public_key = public_key
self.secret_key = secret_key
self.project = project or defaults.PROJECT
self.transport_options = transport_options
self.include_paths = set(o.get('include_paths') or [])
self.exclude_paths = set(o.get('exclude_paths') or [])
self.name = six.text_type(o.get('name') or defaults.NAME)
self.auto_log_stacks = bool(
o.get('auto_log_stacks') or defaults.AUTO_LOG_STACKS)
self.capture_locals = bool(
o.get('capture_locals', defaults.CAPTURE_LOCALS))
self.string_max_length = int(
o.get('string_max_length') or defaults.MAX_LENGTH_STRING)
self.list_max_length = int(
o.get('list_max_length') or defaults.MAX_LENGTH_LIST)
self.site = o.get('site', defaults.SITE)
self.include_versions = o.get('include_versions', True)
self.processors = o.get('processors')
if self.processors is None:
self.processors = defaults.PROCESSORS
context = o.get('context')
if context is None:
context = {'sys.argv': sys.argv[:]}
self.extra = context
self.tags = o.get('tags') or {}
self.module_cache = ModuleProxyCache()
# servers may be set to a NoneType (for Django)
if not self.is_enabled():
self.logger.info(
'Raven is not configured (logging is disabled). Please see the'
' documentation for more information.')
if Raven is None:
Raven = self
self._context = Context()
