def init_error_client(bugTracking):
""" Send traceback to neuropoly servers
:return:
"""
if strtobool(bugTracking):
try:
client = raven.Client(
"https://[email protected]/1238683",
processors=('raven.processors.RemoveStackLocalsProcessor',
'raven.processors.SanitizePasswordsProcessor'))
traceback_to_server(client)
except:
print("Unexpected error: bug tracking may not be functionning.")
def get_client(settings):
"""
Get a Sentry client configured with context data for the current request.
"""
# If the `raven.transport` setting is set to 'gevent', then we use the
# raven-supplied gevent compatible transport.
transport_name = settings.get("raven.transport")
transport = GeventedHTTPTransport if transport_name == "gevent" else None
# Application environment name
environment = settings.get("h.env", "dev")
return raven.Client(
environment=environment,
release=__version__,
transport=transport,
processors=PROCESSORS,
)
def main ():
try:
APP.run ()
except KeyboardInterrupt:
pass
except clip.ClipExit:
sys.exit (0)
except Exception as e:
logtool.log_fault (e)
print >> sys.stderr, ("Something broke!")
if not (getattr (Config, "_nosentry", False)
or Config.get ("user/nosentry", params = {"default": True})):
client = raven.Client (
"https://250e838eaff24eee9461682bc7160904"
":[email protected]/127918")
h = client.captureException ()
print >> sys.stderr, "\t Sentry filed: %s" % h
sys.exit (1)
def get_stack_trace_data_real(exception_class=TypeError, **kwargs):
def _will_throw_type_error(foo, **kwargs):
password = "******" # NOQA F841
the_secret = "nor this" # NOQA F841
a_password_here = "Don't look at me!" # NOQA F841
api_key = "I'm hideous!" # NOQA F841
apiKey = "4567000012345678" # NOQA F841
# TypeError: unsupported operand type(s) for /: 'str' and 'str'
raise exception_class()
client = raven.Client('http://*****:*****@sentry.local/1')
try:
_will_throw_type_error('bar')
except exception_class:
data = client.build_msg('raven.events.Exception')
return data
def capture_exception(self, request=None):
if not RAVEN_AVAILABLE:
return
server_config = Config.instance().get_section_config("Server")
if server_config.getboolean("report_errors"):
if self._client is None:
self._client = raven.Client(CrashReport.DSN,
release=__version__,
raise_send_errors=True)
if request is not None:
self._client.http_context({
"method": request.method,
"url": request.path,
"data": request.json,
})
self._client.tags_context({
"os:name":
platform.system(),
"os:release":
platform.release(),
"os:win_32":
" ".join(platform.win32_ver()),
"os:mac":
"{} {}".format(platform.mac_ver()[0],
platform.mac_ver()[2]),
"os:linux":
" ".join(platform.linux_distribution()),
"python:version":
"{}.{}.{}".format(sys.version_info[0], sys.version_info[1],
sys.version_info[2]),
"python:bit":
struct.calcsize("P") * 8,
"python:encoding":
sys.getdefaultencoding(),
"python:frozen":
"{}".format(hasattr(sys, "frozen"))
})
try:
report = self._client.captureException()
except Exception as e:
log.error("Can't send crash report to Sentry: {}".format(e))
return
log.info("Crash report sent with event ID: {}".format(
self._client.get_ident(report)))
async def gw_init(app):
app.on_response_prepare.append(on_prepare)
app.router.add_route('GET', r'/v{version:\d+}', hello)
app['status'] = GatewayStatus.STARTING
app['datadog'] = DummyDatadog()
app['sentry'] = DummySentry()
if datadog_available:
if app.config.datadog_api_key is None:
log.warning('datadog logging disabled (missing API key)')
else:
datadog.initialize(api_key=app.config.datadog_api_key,
app_key=app.config.datadog_app_key)
app['datadog'] = datadog
log.info('datadog logging enabled')
if raven_available:
if app.config.raven_uri is None:
log.info(
'skipping Sentry initialization due to missing DSN URI...')
else:
app['sentry'] = raven.Client(
app.config.raven_uri,
release=raven.fetch_package_version('backend.ai-manager'))
log.info('sentry logging enabled')
app['dbpool'] = await create_engine(
host=app.config.db_addr[0],
port=app.config.db_addr[1],
user=app.config.db_user,
password=app.config.db_password,
dbname=app.config.db_name,
echo=bool(app.config.verbose),
minsize=4,
maxsize=16,
timeout=30,
pool_recycle=30,
)
app['redis_stat_pool'] = await aioredis.create_redis_pool(
app.config.redis_addr.as_sockaddr(),
timeout=3.0,
encoding='utf8',
db=REDIS_STAT_DB)
app.middlewares.append(exception_middleware_factory)
app.middlewares.append(api_middleware_factory)
def __init__(self, plugin):
self._mutex = threading.RLock()
self.plugin = plugin
self.__items__ = dict()
import raven
self.sentry = raven.Client(
'https://*****:*****@sentry.getanywhere.io/1?verify_ssl=0',
release=plugin._plugin_version)
try:
self.config_path = self.plugin.get_plugin_data_folder(
) + "/.config.yaml"
self._logger = logging.getLogger('octoprint.plugins.anywhere')
self.load_config()
except:
self.sentry.captureException()
import traceback
traceback.print_exc()
def init_logging():
root = logging.getLogger()
root.setLevel(0)
if State.config['sentry']:
patch_gevent_hub_print_exception()
hdlr = SentryHandler(
raven.Client(State.config['sentry'],
transport=GeventedHTTPTransport))
hdlr.setLevel(logging.ERROR)
root.addHandler(hdlr)
hdlr = logging.StreamHandler(sys.stdout)
hdlr.setLevel(getattr(logging, logging.DEBUG))
root.addHandler(hdlr)
root.info(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
root.info('==============================================')
def __init__(self, plugin):
self._mutex = threading.RLock()
self.plugin = plugin
self.__items__ = dict()
import raven
self.sentry = raven.Client(
'https://*****:*****@sentry.thespaghettidetective.com/5?verify_ssl=0',
release=plugin._plugin_version)
try:
self.config_path = self.plugin.get_plugin_data_folder(
) + "/.config.yaml"
self._logger = logging.getLogger('octoprint.plugins.anywhere')
self.load_config()
except:
self.sentry.captureException()
import traceback
traceback.print_exc()
def update_sentry_config(self, config):
new_config = self.sentry_config.copy()
new_config.update(config)
if new_config == self.sentry_config:
return
self.sentry_config = new_config
if self.sentry_config.get("dsn"):
try:
# Lazy-load raven as this file is loaded by a lot of tools
import raven
self.raven_client = raven.Client(**self.sentry_config)
except ImportError:
self.raven_client = None
self.log.warning(
"Cannot enable Sentry.io sending: importing 'raven' failed"
)
else:
self.raven_client = None
def setup(dsn=None, name=None, level=logging.WARNING, **kwargs):
global client
dsn = dsn or os.getenv("SENTRY_DSN")
if not dsn:
raise ValueError("you must give SENTRY_DSN, or set it in env")
client = raven.Client(dsn,
name=name,
processors=raven.conf.defaults.PROCESSORS +
(AdditionalInfoProcessor.__module__ + "." +
AdditionalInfoProcessor.__name__, ),
**kwargs)
handler = raven.handlers.logging.SentryHandler(client)
handler.setLevel(level)
raven.conf.setup_logging(handler)
return client
def includeme(config):
# Create a client and stash it in the registry
client = raven.Client(
dsn=config.registry.settings.get("sentry.dsn"),
include_paths=["warehouse"],
release=config.registry.settings["warehouse.commit"],
transport=config.registry.settings.get("sentry.transport"),
)
config.registry["raven.client"] = client
# Create a request method that'll get us the Raven client in each request.
config.add_request_method(_raven, name="raven", reify=True)
# Add a tween that will handle catching any exceptions that get raised.
config.add_tween("warehouse.raven.raven_tween_factory", over=EXCVIEW)
# Wrap the WSGI object with the middle to catch any exceptions we don't
# catch elsewhere.
config.add_wsgi_middleware(raven.middleware.Sentry, client=client)
def get_app():
app = Flask("SwissVoice")
log.debug("Loading config")
app.config.from_object(config.default)
app.config.from_object(config.environment)
log.debug("setting up Sentry...")
sentry_client = raven.Client(app.config["SENTRY_DSN"], release=__version__)
Sentry(app, sentry_client)
sentry_handler = SentryHandler(sentry_client)
sentry_handler.setLevel(logging.ERROR)
setup_logging(sentry_handler)
register_converters(app)
app.json_encoder = SwissJsonEncoder
log.info("app setup!")
return app
def handler(event, context):
try:
domains = os.environ.get('LETSENCRYPT_DOMAINS', None)
if should_provision(domains):
cert = provision_cert(os.environ.get('LETSENCRYPT_EMAIL', None),
domains)
upload_cert_to_acm(cert, domains)
if os.environ.get('S3_BUCKET_NAME', None):
upload_cert_to_s3(cert, domains,
os.environ.get('S3_BUCKET_NAME', None))
if os.environ.get('NOTIFICATION_SNS_ARN', None):
notify_via_sns(os.environ.get('NOTIFICATION_SNS_ARN', None),
domains, cert['certificate'])
except:
if os.environ.get('SENTRY_DSN', None):
client = raven.Client(os.environ.get('SENTRY_DSN', None),
transport=raven.transport.http.HTTPTransport)
client.captureException()
raise
def __init__(self,
dsn_env_var='SENTRY_DSN',
base_url_env_var='SENTRY_BASE_URL',
tags_map_env_var='SENTRY_TAG_MAP'):
# type: (Optional[str], Optional[str], Optional[str]) -> None
self._client = None
self._base_url = None
if base_url_env_var:
self._base_url = os.environ.get(base_url_env_var, None)
self._tag_map = {} # type: Dict[str, str]
if tags_map_env_var and os.environ.get(tags_map_env_var):
try:
for pair in os.environ[tags_map_env_var].split(','):
tag, env_var = pair.split('=')
self._tag_map[env_var.strip()] = tag.strip()
except ValueError:
raise gluetool.glue.GlueError(
'Cannot parse content of {} environment variable'.format(
tags_map_env_var))
if not dsn_env_var:
return
dsn = os.environ.get(dsn_env_var, None)
if not dsn:
return
self._client = raven.Client(dsn, install_logging_hook=True)
# Enrich Sentry context with information that are important for us
context = {}
# env variables
for name, value in iteritems(os.environ):
context['env.{}'.format(name)] = value
self._client.extra_context(context)
def captureException(self, exception, value, tb):
if not RAVEN_AVAILABLE:
return
if os.path.exists(".git"):
log.warning(
"A .git directory exist crash report is turn off for developers"
)
return
local_server = Servers.instance().localServerSettings()
if local_server["report_errors"]:
if self._client is None:
self._client = raven.Client(CrashReport.DSN,
release=__version__)
self._client.tags_context({
"os:name":
platform.system(),
"os:release":
platform.release(),
"os:win_32":
" ".join(platform.win32_ver()),
"os:mac":
"{} {}".format(platform.mac_ver()[0],
platform.mac_ver()[2]),
"os:linux":
" ".join(platform.linux_distribution()),
"python:version":
"{}.{}.{}".format(sys.version_info[0], sys.version_info[1],
sys.version_info[2]),
"python:bit":
struct.calcsize("P") * 8,
"python:encoding":
sys.getdefaultencoding(),
"python:frozen":
"{}".format(hasattr(sys, "frozen"))
})
try:
report = self._client.captureException((exception, value, tb))
except Exception as e:
log.error("Can't send crash report to Sentry: {}".format(e))
return
log.info("Crash report sent with event ID: {}".format(
self._client.get_ident(report)))
def sentry_middleware_factory(sentry_kwargs=None):
"""
Aiohttp Middleware for logging error messages automatically on Sentry
"""
if sentry_kwargs is None:
sentry_kwargs = {}
sentry_kwargs = {
'dsn': sentry_option("dsn"),
'transport': AioHttpTransport,
'enable_breadcrumbs': False,
**sentry_kwargs,
}
# Create a new raven client with the specified configuration
_client = raven.Client(**sentry_kwargs)
# Set the tags context with an application ID for all reported events
_client.tags_context({"app_id": APP_NAME})
@web.middleware
async def impl(request: web.Request, handler: Callable) -> web.Response:
try:
return await handler(request)
except:
_client.captureException(
data={
'request': {
'query_string': request.query_string,
'cookies': request.headers.get('Cookie', ''),
'headers': dict(request.headers),
'url': request.path,
'method': request.method,
'env': {
'REMOTE_ADDR':
request.transport.get_extra_info('peername')[0],
}
}
})
raise
return impl
def init_logging(level='INFO'):
root = logging.getLogger()
root.setLevel(0)
patch_gevent_hub_print_exception()
if State.config.get('sentry'):
hdlr = SentryHandler(raven.Client(State.config['sentry'], transport=GeventedHTTPTransport))
hdlr.setLevel(logging.ERROR)
root.addHandler(hdlr)
fmter = ServerLogFormatter()
hdlr = logging.StreamHandler(sys.stdout)
hdlr.setLevel(getattr(logging, level))
hdlr.setFormatter(fmter)
root.addHandler(hdlr)
root.info(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
root.info('==============================================')
def __init__(self):
self.sentry = raven.Client(dsn=os.environ.get("SENTRY_DSN", None))
self.redis = redis.StrictRedis(connection_pool=redis_pool)
self.downloader = downloader.Downloader(download_folder='audio_cache')
self.players = {}
self.aiolocks = defaultdict(asyncio.Lock)
self.exit_signal = None
self.init_ok = False
load_config(self)
migrate_redis(self.redis)
# TODO: Do these properly
ssd_defaults = {'last_np_msg': None, 'availability_paused': False}
self.server_specific_data = defaultdict(lambda: dict(ssd_defaults))
super().__init__()
self.aiosession = aiohttp.ClientSession(loop=self.loop)
self.http.user_agent += ' MusicBot/MODIFIED'
def alert(dsn, message, level='INFO', data=None):
"""
Send a sentry alert
:param dsn: The sentry DSN, in the form of
``{protocol}://{public}:{private}@{host}/{path}{project id}``.
The protocol is always forced to use the requests+http(s) transport if
the requests library is present, or sync+http(s) otherwise. See
`here <http://raven.readthedocs.org/en/latest/transports/>`_ for more
information. If `dsn` is set to ``None``, though, raven defaults to
using the `SENTRY_DSN` environment variable
:param message: The message string you want to send
:param level: The level of the message
(``DEBUG``, ``INFO``, ``WARN``, ``ERROR``)
:param extra: Any extra parameters you want sent with the message
"""
if data is None:
data = {}
if dsn is not None:
parsed = urlparse.urlparse(dsn)
protocol = parsed.scheme
if protocol.startswith('http'):
try:
import requests
assert requests # silence pyflake
protocol = 'requests+' + protocol
except ImportError:
protocol = 'sync+' + protocol
dsn = urlparse.urlunparse([protocol] + list(parsed[1:]))
log.debug('raven.alert called with: %s, %s, %s, %s', dsn, message, level,
str(data))
client = raven.Client(dsn=dsn)
level = getattr(logging, level.upper(), 'INFO')
data.update({'level': level})
data = client.build_msg('raven.events.Message', message=message, data=data)
log.info('message object: %s', str(data))
client.send(**data)
return True
def capture_exception(self, exception, value, tb):
if not RAVEN_AVAILABLE:
return
report_errors = True
if report_errors:
if self._client is None:
self._client = raven.Client(CrashReport.DSN,
release=__version__)
tags = {
"os:name":
platform.system(),
"os:release":
platform.release(),
"python:version":
"{}.{}.{}".format(sys.version_info[0], sys.version_info[1],
sys.version_info[2]),
"python:bit":
struct.calcsize("P") * 8,
"python:encoding":
sys.getdefaultencoding(),
"python:frozen":
"{}".format(hasattr(sys, "frozen"))
}
if sys.platform == 'win32':
tags['os:win32'] = " ".join(platform.win32_ver())
elif sys.platform == 'darwin':
tags['os:mac'] = "{} {}".format(platform.mac_ver()[0],
platform.mac_ver()[2])
else:
tags['os:linux'] = " ".join(platform.linux_distribution())
self._client.tags_context(tags)
try:
report = self._client.captureException((exception, value, tb))
except Exception as e:
log.error("Can't send crash report to Sentry: {}".format(e))
return
log.info("Crash report sent with event ID: {}".format(
self._client.get_ident(report)))
def get_raven_client(cls):
repositories = g.versions.keys()
release_str = '|'.join(
"%s:%s" % (repo, commit_hash)
for repo, commit_hash in sorted(g.versions.items()))
release_hash = md5(release_str).hexdigest()
RAVEN_CLIENT = raven.Client(
dsn=g.sentry_dsn,
# use the default transport to send errors from another thread:
transport=raven.transport.threaded.ThreadedHTTPTransport,
include_paths=repositories,
processors=[
'raven.processors.SanitizePasswordsProcessor',
'r2.lib.log.SanitizeStackLocalsProcessor',
],
release=release_hash,
environment=g.pool_name,
include_versions=False, # handled by get_module_versions
)
return RAVEN_CLIENT
def setup_sentry(name, channel, dsn):
"""
Setup sentry account using taskcluster secrets
"""
# Detect environment
if "TASK_ID" in os.environ:
site = "taskcluster"
elif "DYNO" in os.environ:
site = "heroku"
else:
site = "unknown"
sentry_client = raven.Client(dsn=dsn,
site=site,
name=name,
environment=channel)
sentry_handler = raven.handlers.logbook.SentryHandler(
sentry_client, level=logbook.WARNING, bubble=True)
sentry_handler.push_application()
def init_logging(gn_env: GNEnvironment) -> None:
if len(gn_env.config) == 0 or gn_env.config.get(ConfigKeys.TESTING, False):
# assume we're testing
return
logging_type = gn_env.config.get(ConfigKeys.TYPE, domain=ConfigKeys.LOGGING, default='logger')
if logging_type is None or len(logging_type.strip()) == 0 or logging_type in ['logger', 'default', 'mock']:
return
if logging_type != 'sentry':
raise RuntimeError('unknown logging type %s' % logging_type)
dsn = gn_env.config.get(ConfigKeys.DSN, domain=ConfigKeys.LOGGING, default='')
if dsn is None or len(dsn.strip()) == 0:
logger.warning('sentry logging selected but no DSN supplied, not configuring senty')
return
import raven
import socket
from git.cmd import Git
home_dir = os.environ.get('DINO_HOME', default=None)
if home_dir is None:
home_dir = '.'
tag_name = Git(home_dir).describe()
gn_env.sentry = raven.Client(
dsn=dsn,
environment=os.getenv(ENV_KEY_ENVIRONMENT),
name=socket.gethostname(),
release=tag_name
)
def capture_exception(e_info) -> None:
try:
gn_env.sentry.captureException(e_info)
except Exception as e2:
logger.exception(e_info)
logger.error('could not capture exception with sentry: %s' % str(e2))
gn_env.capture_exception = capture_exception
def init(level, sentry_dsn, release, colored=False):
patch_gevent_hub_print_exception()
root = logging.getLogger()
root.setLevel(0)
hdlr = logging.FileHandler('client_log.txt', encoding='utf-8')
hdlr.setLevel(logging.INFO)
root.addHandler(hdlr)
if sentry_dsn:
hdlr = SentryHandler(
raven.Client(sentry_dsn,
transport=GeventedHTTPTransport,
release=release))
hdlr.setLevel(logging.ERROR)
root.addHandler(hdlr)
hdlr = logging.StreamHandler(sys.stdout)
hdlr.setLevel(getattr(logging, level))
logging.getLogger('sentry.errors').setLevel(1000)
if colored:
from colorlog import ColoredFormatter
formatter = ColoredFormatter("%(log_color)s%(message)s%(reset)s",
log_colors={
'CRITICAL': 'bold_red',
'ERROR': 'red',
'WARNING': 'yellow',
'INFO': 'green',
'DEBUG': 'blue',
})
hdlr.setFormatter(formatter)
root.addHandler(hdlr)
root.info(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
root.info('==============================================')
def setup_sentry(project_name, channel, SENTRY_DSN):
"""
Setup sentry account using taskcluster secrets
"""
import raven
import raven.handlers.logbook
sentry_client = raven.Client(
dsn=SENTRY_DSN,
site=project_name,
name="mozilla/release-services",
environment=channel,
# TODO:
# release=read(VERSION) we need to promote that as well via secrets
# tags=...
# repos=...
)
sentry_handler = raven.handlers.logbook.SentryHandler(
sentry_client, level=logbook.WARNING, bubble=True)
sentry_handler.push_application()
def sentry(website):
sentry_dsn = os.environ.get('SENTRY_DSN')
if sentry_dsn is not None:
sentry = raven.Client(sentry_dsn)
def tell_sentry(request):
cls, response = sys.exc_info()[:2]
if cls is aspen.Response:
if response.code < 500:
return
kw = {
'extra': {
"filepath": request.fs,
"request": str(request).splitlines()
}
}
exc = sentry.captureException(**kw)
ident = sentry.get_ident(exc)
aspen.log_dammit("Exception reference: " + ident)
website.hooks.error_early += [tell_sentry]
def __init__(self,
load_state: 'List[SystemObject]' = None,
load_config: 'Dict[str, Any]' = None,
**traits):
super().__init__(**traits)
if not self.name:
self.name = self.__class__.__name__
if self.name == 'System':
self.name = os.path.split(sys.argv[0])[-1].replace('.py', '')
# Initialize Sentry / raven client, if is configured
if not self.raven_client and self.raven_dsn:
self.raven_client = raven.Client(
self.raven_dsn,
release=__version__,
tags={'automate-system': self.name})
self._initialize_logging()
self.worker_thread = StatusWorkerThread(name="Status worker thread",
system=self)
self.logger.info('Initializing services')
self._initialize_services()
self.logger.info('Initializing namespace')
self._initialize_namespace(load_state)
if load_config:
self.logger.info('Loading config')
for obj_name, status in load_config.items():
if hasattr(self, obj_name):
getattr(self, obj_name).status = status
self.logger.info('Initialize user services')
self._setup_user_services()
if self.worker_autostart:
self.logger.info('Starting worker thread')
self.worker_thread.start()
self.post_init_trigger = True
def run_requests(args):
if args.enable_sentry:
try:
git_sha = raven.fetch_git_sha("..")
except Exception:
git_sha = None
sentry_client = raven.Client(release=git_sha) # noqa:
# TODO: switch to using JsonLinePusher
file_worker = IngestFileWorker(
try_spn2=not args.no_spn2,
html_quick_mode=args.html_quick_mode,
)
fileset_worker = IngestFilesetWorker(try_spn2=not args.no_spn2, )
for line in args.json_file:
request = json.loads(line.strip())
if request["ingest_type"] in [
"dataset",
]:
result = fileset_worker.process(request)
else:
result = file_worker.process(request)
print(json.dumps(result, sort_keys=True))
def init_error_client():
""" Send traceback to neuropoly servers
:return:
"""
if os.getenv('SENTRY_DSN'):
logger.debug('Configuring sentry report')
try:
client = raven.Client(
release=__version__,
processors=('raven.processors.RemoveStackLocalsProcessor',
'raven.processors.SanitizePasswordsProcessor'),
)
server_log_handler(client)
traceback_to_server(client)
old_exitfunc = sys.exitfunc
def exitfunc():
sent_something = False
try:
# implementation-specific
import atexit
for handler, args, kw in atexit._exithandlers:
if handler.__module__.startswith("raven."):
sent_something = True
except:
pass
old_exitfunc()
if sent_something:
print(
"Note: you can opt out of Sentry reporting by editing the file ${SCT_DIR}/bin/sct_launcher and delete the line starting with \"export SENTRY_DSN\""
)
sys.exitfunc = exitfunc
except raven.exceptions.InvalidDsn:
# This could happen if sct staff change the dsn
logger.debug('Sentry DSN not valid anymore, not reporting errors')
