def set_sentry_client(sentry_dsn, basedir):
"""Sets a Sentry client using a given sentry_dsn
To clear the client, pass in something falsey like ``''`` or ``None``.
"""
global _sentry_client
if sentry_dsn:
version_info = get_version_info(basedir)
commit = version_info.get('commit')[:8]
_sentry_client = Client(
dsn=sentry_dsn,
include_paths=['antenna'],
tags={'commit': commit}
)
logger.info('Set up sentry client')
else:
_sentry_client = None
logger.info('Removed sentry client')
python类Client()的实例源码
def prepare():
global country_count,countries,file_type,questions,poll_id,write_questions,write_results,results,position,national,worldwide
print "Preparing ..."
if production:
client = Client(sentry_url)
handler = SentryHandler(client)
setup_logging(handler)
logger = logging.getLogger(__name__)
mysql_connect()
if len(sys.argv) == 1: manual_run()
elif len(sys.argv) >= 2:
file_type = sys.argv[1]
if file_type == "q": automatic_questions()
elif file_type == "r": automatic_results()
elif file_type == "v": automatic_votes()
mysql_close()
make_language_table()
def test_will_alert(self, node, rule, testapp):
match = RuleMatch(
rule=rule,
node=node.to_dict(),
result={
'name': 'foo',
'action': 'added',
'timestamp': dt.datetime.utcnow(),
'columns': {'boo': 'baz', 'kung': 'bloo'},
}
)
with mock.patch.object(raven.Client, 'captureMessage', return_value=None) as pmock:
alerter = SentryAlerter(self.config)
alerter.handle_alert(node.to_dict(), match)
assert pmock.called
_, kwargs = pmock.call_args
assert kwargs['message'] == rule.template.safe_substitute(
match.result['columns'],
**node.to_dict()
).rstrip()
def main(loop, inventory):
"""
Trigger to populate kinto with the last inventories.
"""
server_url = os.getenv('SERVER_URL', 'http://localhost:8888/v1')
bucket = os.getenv('BUCKET', 'build-hub')
collection = os.getenv('COLLECTION', 'releases')
kinto_auth = tuple(os.getenv('AUTH', 'user:pass').split(':'))
kinto_client = kinto_http.Client(server_url=server_url, auth=kinto_auth,
bucket=bucket, collection=collection,
retry=NB_RETRY_REQUEST)
# Create bucket/collection and schemas.
if INITIALIZE_SERVER:
await initialize_kinto(loop, kinto_client, bucket, collection)
# Download CSVs, deduce records and push to Kinto.
session = aiobotocore.get_session(loop=loop)
boto_config = botocore.config.Config(signature_version=botocore.UNSIGNED)
async with session.create_client('s3', region_name=REGION_NAME, config=boto_config) as client:
keys_stream = list_manifest_entries(loop, client, inventory)
csv_stream = download_csv(loop, client, keys_stream)
records_stream = csv_to_records(loop, csv_stream, skip_incomplete=True)
await to_kinto(loop, records_stream, kinto_client, skip_existing=True)
def _install_sentry():
if "AVALON_SENTRY" not in Session:
return
try:
from raven import Client
from raven.handlers.logging import SentryHandler
from raven.conf import setup_logging
except ImportError:
# Note: There was a Sentry address in this Session
return log.warning("Sentry disabled, raven not installed")
client = Client(Session["AVALON_SENTRY"])
# Transmit log messages to Sentry
handler = SentryHandler(client)
handler.setLevel(logging.WARNING)
setup_logging(handler)
self._sentry_client = client
self._sentry_logging_handler = handler
log.info("Connected to Sentry @ %s" % Session["AVALON_SENTRY"])
def __init__(self, server, sock):
"""
Initialize a Client object
:param server: server object
:param sock: socket connection object
:return:
"""
self.__timestamp = time.time()
self.__readbuffer = ""
self.__writebuffer = ""
self.__sentPing = False
self.__handleCommand = self.passHandler
self.server = server
self.socket = sock
(self.ip, self.port) = sock.getpeername()
self.IRCUsername = ""
self.banchoUsername = ""
self.supposedUsername = ""
self.supposedUserID = 0
self.joinedChannels = []
def disconnect(self, quitmsg = "Client quit", callLogout = True):
"""
Disconnects this client from the IRC server
:param quitmsg: IRC quit message. Default: 'Client quit'
:param callLogout: if True, call logoutEvent on bancho
:return:
"""
# Send error to client and close socket
self.message("ERROR :{}".format(quitmsg))
self.socket.close()
log.info("[IRC] Disconnected connection from {}:{} ({})".format(self.ip, self.port, quitmsg))
# Remove socket from server
self.server.removeClient(self, quitmsg)
# Bancho logout
if callLogout and self.banchoUsername != "":
chat.IRCDisconnect(self.IRCUsername)
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 ready(self):
# Using a string here means the worker will not have to
# pickle the object when using Windows.
app.config_from_object('django.conf:settings')
installed_apps = [app_config.name for app_config in apps.get_app_configs()]
app.autodiscover_tasks(lambda: installed_apps, force=True)
if hasattr(settings, 'RAVEN_CONFIG'):
# Celery signal registration
from raven import Client as RavenClient
from raven.contrib.celery import register_signal as raven_register_signal
from raven.contrib.celery import register_logger_signal as raven_register_logger_signal
raven_client = RavenClient(dsn=settings.RAVEN_CONFIG['DSN'])
raven_register_logger_signal(raven_client)
raven_register_signal(raven_client)
def ready(self):
# Using a string here means the worker will not have to
# pickle the object when using Windows.
app.config_from_object('django.conf:settings')
installed_apps = [app_config.name for app_config in apps.get_app_configs()]
app.autodiscover_tasks(lambda: installed_apps, force=True)
{% if cookiecutter.use_sentry_for_error_reporting == 'y' -%}
if hasattr(settings, 'RAVEN_CONFIG'):
# Celery signal registration
from raven import Client as RavenClient
from raven.contrib.celery import register_signal as raven_register_signal
from raven.contrib.celery import register_logger_signal as raven_register_logger_signal
raven_client = RavenClient(dsn=settings.RAVEN_CONFIG['DSN'])
raven_register_logger_signal(raven_client)
raven_register_signal(raven_client)
{%- endif %}
def __init__(self, bot):
self.bot = bot
self.settings = dataIO.load_json('data/sentry/settings.json')
if self.settings['dsn'] is None:
log.warning('Sentry: DSN key is not set. Not sending logs!')
else:
if self.settings['ssl'] is False:
self.raven = Client(self.settings['dsn'] + '?verify_ssl=0')
else:
self.raven = Client(self.settings['dsn'])
self.handler = SentryHandler(self.raven)
self.handler.setLevel(self.settings['level'])
self.logger = logging.getLogger("red").addHandler(self.handler)
setup_logging(self.handler)
# --- Raven settings
self.raven.tags = self.settings['tags']
if self.settings['name'] is not None:
self.raven.name = self.settings['name']
if self.settings['environment'] is not None:
self.raven.environment = self.settings['environment']
if self.settings.get('ignore'):
self.raven.ignore = self.settings['ignore']
def run_twitter_fetcher():
sentry = Client(SENTRY_DSN)
while True:
try:
l.info('starting streamer with {} emojis...'.format(len(EMOJIS)))
sentry.captureMessage('starting `emoji-prediction`')
streamer = TwitterEmojiStreamer(TwitterAuth.CONSUMER_KEY,
TwitterAuth.CONSUMER_SECRET,
TwitterAuth.ACCESS_TOKEN,
TwitterAuth.ACCESS_TOKEN_SECRET)
streamer.statuses.filter(track=EMOJIS, language=LANGUAGE)
# requests.exceptions.ConnectionError
except ChunkedEncodingError:
l.debug('chunked_encoding_error happened')
pass
except ConnectionError:
l.debug('connection_error happened')
pass
except UnknownTwitterEmojiException as e:
l.error('unknown exception ocurred')
l.error(e)
sentry.captureException()
def setup(app, version:str='undefined'):
environment = getattr(app.settings, 'ROLE', None) or os.environ.get('ROLE')
dsn = getattr(app.settings, 'SENTRY_DSN', None)
tags = getattr(app.settings, 'SENTRY_TAGS', None)
client = Client(dsn=dsn, transport=AioHttpTransport,
version=version, environment=environment,
tags=tags)
handler = DjaioSentryHandler(client=client)
handler.setLevel(logging.ERROR)
setup_logging(handler)
app.raven = client
def configure_sentry(in_debug=False):
"""
Configure the Raven client, or create a dummy one if `in_debug` is `True`.
"""
key = 'eaee971c463b49678f6f352dfec497a9'
# the public DSN URL is not available on the Python client
# so we're exposing the secret and will be revoking it on abuse
# https://github.com/getsentry/raven-python/issues/569
secret = '4f37fdbde03a4753b78abb84d11f45ab'
project_id = '191660'
dsn = 'https://{key}:{secret}@sentry.io/{project_id}'.format(
key=key, secret=secret, project_id=project_id)
if in_debug:
client = DebugRavenClient()
else:
client = Client(dsn=dsn, release=__version__)
# adds context for Android devices
if platform == 'android':
from jnius import autoclass
Build = autoclass("android.os.Build")
VERSION = autoclass('android.os.Build$VERSION')
android_os_build = {
'model': Build.MODEL,
'brand': Build.BRAND,
'device': Build.DEVICE,
'manufacturer': Build.MANUFACTURER,
'version_release': VERSION.RELEASE,
}
client.user_context({'android_os_build': android_os_build})
# Logger.error() to Sentry
# https://docs.sentry.io/clients/python/integrations/logging/
handler = SentryHandler(client)
handler.setLevel(LOG_LEVELS.get('error'))
setup_logging(handler)
return client
def _setup_logging(logger, options):
formatter = logging.Formatter('%(asctime)s %(process)s %(levelname)s '
'%(message)s')
logger.setLevel(logging.DEBUG)
if options["log_file"]:
filename = options["log_file"]
file_handler = logging.handlers.WatchedFileHandler(filename)
file_handler.setFormatter(formatter)
if options["debug"]:
file_handler.setLevel(logging.DEBUG)
else:
file_handler.setLevel(logging.INFO)
logger.addHandler(file_handler)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.CRITICAL)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
if options["sentry_dsn"] and _has_raven:
client = raven.Client(options["sentry_dsn"],
enable_breadcrumbs=False,
transport=raven.transport.HTTPTransport)
# Add Sentry handle to application logger.
sentry_handler = SentryHandler(client)
sentry_handler.setLevel(logging.WARNING)
logger.addHandler(sentry_handler)
null_loggers = [
logging.getLogger("sentry.errors"),
logging.getLogger("sentry.errors.uncaught")
]
for null_logger in null_loggers:
null_logger.handlers = [logging.NullHandler()]
if options["debug"]:
stream_handler.setLevel(logging.DEBUG)
elif options["info"]:
stream_handler.setLevel(logging.INFO)
def _configure_sentry(self, raven_config):
import raven
from raven.contrib.celery import (register_signal,
register_logger_signal)
client = raven.Client(**raven_config)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def start_loop(cfg: Config, noop=False):
handlers = []
handlers.append(StreamHandler(sys.stdout, level=cfg.log_level))
logger = Logger("Heart")
logger.info("Initializing Oshino v{0}".format(get_version()))
logger.info("Running forever in {0} seconds interval. Press Ctrl+C to exit"
.format(cfg.interval))
if cfg.sentry_dsn:
try:
client = SentryClient(cfg.sentry_dsn)
handlers.append(SentryHandler(client,
level=logbook.ERROR,
bubble=True))
except InvalidDsn:
logger.warn("Invalid Sentry DSN '{0}' providen. Skipping"
.format(cfg.sentry_dsn))
setup = NestedSetup(handlers)
setup.push_application()
loop = create_loop()
try:
loop.run_until_complete(main_loop(cfg,
logger,
cfg.riemann.transport(noop),
forever,
loop=loop))
finally:
loop.close()
def ready(self):
# Using a string here means the worker will not have to
# pickle the object when using Windows.
app.config_from_object('django.conf:settings')
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS, force=True)
if hasattr(settings, 'RAVEN_CONFIG'):
# Celery signal registration
from raven import Client as RavenClient
from raven.contrib.celery import register_signal as raven_register_signal
from raven.contrib.celery import register_logger_signal as raven_register_logger_signal
raven_client = RavenClient(dsn=settings.RAVEN_CONFIG['DSN'])
raven_register_logger_signal(raven_client)
raven_register_signal(raven_client)
def create_raven(sentry_dsn=SENTRY_DSN, transport='sync', _raven=None):
if _raven is not None:
return _raven
klass = DebugRavenClient if TESTING else RavenClient
client = klass(
dsn=sentry_dsn,
transport=RAVEN_TRANSPORTS[transport],
processors=(
'raven.processors.RemoveStackLocalsProcessor',
'miracle.log.SecretsProcessor',
),
release=VERSION)
return client
def create_client(conf, app_version='__UNKNOWN__', ignore_common_http=True):
"""Creates a sentry client.
:param app_version: (string): App version sent to sentry for making events more rich
:param conf['SENTRY_DSN']: (string, required): DSN of sentry server
:param conf['SENTRY_SITE']: (string): The site description of the deployment.
:returns: An initialized ``raven.Client`` instance.
"""
ignore_exceptions = []
if ignore_common_http:
ignore_exceptions = [
'werkzeug.exceptions.BadRequest', # 400
'werkzeug.exceptions.Unauthorized', # 401
'werkzeug.exceptions.Forbidden', # 403
'werkzeug.exceptions.NotFound', # 404
'werkzeug.exceptions.MethodNotAllowed', # 405
'marshmallow.exceptions.ValidationError', # Marshmallow Validation Error.
'webargs.core.ValidationError', # Webargs Validation Error
]
client = Client(
conf['SENTRY_DSN'],
site=conf.get('SENTRY_SITE'),
release=app_version,
ignore_exceptions=ignore_exceptions
)
return client
def on_configure(self):
client = raven.Client(settings.SENTRY_DSN)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def report_exceptions(fn):
def wrapped(*args, **kwargs):
try:
fn(*args, **kwargs)
except Exception:
client = Sentry(
os.environ["SENTRY_DSN"],
transport=SentryHTTPTransport,
environment=os.environ["ENV"],
)
client.captureException()
raise
return wrapped
def sentry_report_exception(context=None):
sentry = raven.Client(SENTRY_URL)
if context is not None:
with sentry.context:
sentry.context.merge(context)
try:
sentry.captureException()
finally:
sentry.context.clear()
def load_sentry(self):
if self.clientid == "":
return
self.raven = Client(self.clientid, transport=AioHttpTransport)
self.handler = SentryHandler(self.raven)
setup_logging(self.handler)
log.debug("Sentry handler activated.")
def sentryio(self):
"""
Sentry.io Client stuff
"""
def make_celery(app, celery):
""" From http://flask.pocoo.org/docs/0.10/patterns/celery/ """
# Register our custom serializer type before updating the configuration.
from kombu.serialization import register
from doorman.celery_serializer import djson_dumps, djson_loads
register(
'djson', djson_dumps, djson_loads,
content_type='application/x-djson',
content_encoding='utf-8'
)
# Actually update the config
celery.config_from_object(app.config)
# Register Sentry client
if 'SENTRY_DSN' in app.config and app.config['SENTRY_DSN']:
client = Client(app.config['SENTRY_DSN'])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def __init__(self, config):
self.client = Client(
config['dsn'],
auto_log_stacks=False,
enable_breadcrumbs=False,
)
self.config = config
def ready(self): # pragma: no cover
# Using a string here means the worker will not have to
# pickle the object when using Windows.
app.config_from_object('django.conf:settings')
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS, force=True)
if hasattr(settings, 'RAVEN_CONFIG'):
# Celery signal registration
from raven import Client as RavenClient
from raven.contrib.celery import register_signal as raven_register_signal
from raven.contrib.celery import register_logger_signal as raven_register_logger_signal
raven_client = RavenClient(dsn=settings.RAVEN_CONFIG['DSN'])
raven_register_logger_signal(raven_client)
raven_register_signal(raven_client)
def __init__(self, bot):
super().__init__(bot)
self.sentry = raven.Client(bot.cfg['monitoring']['raven_client_url'])
def on_configure(self):
if 'SENTRY_DSN' in os.environ:
client = raven.Client(os.environ.get('SENTRY_DSN'))
register_logger_signal(client)
register_signal(client)