Python raven.Client() Examples

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 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 __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 __init__(self, plugin):
        self._mutex = threading.RLock()
        self.plugin = plugin
        self.__items__ = dict()

        import raven
        self.sentry = raven.Client(
                'https://2b979afa37f849c1af93bcc9c88aded8:dea2054d56014d53b59376084b23e142@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 setup(self):
        sentry_config = self.container.config.get('SENTRY')

        sentry_config = sentry_config or {}
        dsn = sentry_config.get('DSN', None)
        kwargs = sentry_config.get('CLIENT_CONFIG', {})

        self.client = Client(dsn, transport=EventletHTTPTransport, **kwargs)

        report_expected_exceptions = sentry_config.get(
            'REPORT_EXPECTED_EXCEPTIONS', True
        )
        user_type_context_keys = sentry_config.get(
            'USER_TYPE_CONTEXT_KEYS', USER_TYPE_CONTEXT_KEYS
        )
        tag_type_context_keys = sentry_config.get(
            'TAG_TYPE_CONTEXT_KEYS', TAG_TYPE_CONTEXT_KEYS
        )

        self.report_expected_exceptions = report_expected_exceptions
        self.user_type_context_keys = user_type_context_keys
        self.tag_type_context_keys = tag_type_context_keys 

def configure_logger(verbose):
    def set_raven_client():
        from polyaxon_cli.managers.cli import CliConfigManager

        cli_config = CliConfigManager.get_config()
        if cli_config and cli_config.log_handler and cli_config.log_handler.decoded_dsn:
            import raven

            client = raven.Client(
                dsn=cli_config.log_handler.decoded_dsn,
                release=cli_config.current_version,
                environment=cli_config.log_handler.environment,
                tags=cli_config.log_handler.tags,
                processors=('raven.processors.SanitizePasswordsProcessor',))
            client.error_logger.disabled = True
            return client
        return None

    set_raven_client()
    log_level = logging.DEBUG if verbose else logging.INFO
    logging.basicConfig(format='%(message)s', level=log_level, stream=sys.stdout) 

def main():
    """Wrapper around run() to setup sentry"""

    sentry_dsn = os.environ.get('POLYSH_SENTRY_DSN')

    if sentry_dsn:
        from raven import Client
        client = Client(
            dsn=sentry_dsn,
            release='.'.join(map(str, VERSION)),
            ignore_exceptions=[
                KeyboardInterrupt
            ]
        )

        try:
            run()
        except Exception:
            client.captureException()

    else:
        run() 

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 sentrytest(self):
        """return true if we managed to send a sample raven exception"""
        if not (self.config.sentry and self.config.sentry.dsn):
            raise SentryConfigurationError('sentry dsn not configured')

        try:
            version = raven.fetch_package_version('crontabber')
        except Exception:
            version = None
            self.config.logger.warning(
                'Unable to extract version of crontabber',
                exc_info=True
            )
        client = raven.Client(
            dsn=self.config.sentry.dsn,
            release=version
        )
        identifier = client.captureMessage(
            'Sentry test sent from crontabber'
        )
        self.config.logger.info(
            'Sentry successful identifier: %s', identifier
        )
        return True 

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 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 get_dependency(self, worker_ctx):
        """ Expose the Raven Client directly to the worker
        """
        return self.client 

def __init__(self):
        """Construct new sentry wrapper."""
        if config["logging"]["sentry_enabled"]:
            self.initialized = True
            self.sentry = Client(config["logging"]["sentry_token"]) 

def patched_sentry():
    with patch.object(Client, 'send'):
        yield 

def __init__(self):
        """Construct new sentry wrapper."""
        if config["logging"]["sentry_enabled"]:
            self.initialized = True
            self.sentry = Client(
                config["logging"]["sentry_token"], ignore_exceptions=[TimedOut],
            ) 

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 __init__(self, config):
        self.client = Client(
            config['dsn'],
            auto_log_stacks=False,
            enable_breadcrumbs=False,
        )
        self.config = config 

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 on_configure(self):
        if settings.PDB_SENTRY_DSN:  # ignore for coverage
            client = raven.Client(settings.PDB_SENTRY_DSN)
            client.release = raven.fetch_git_sha(os.path.dirname(os.pardir))

            # register a custom filter to filter out duplicate logs
            register_logger_signal(client)

            # hook into the Celery error handler
            register_signal(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')
        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)

        if hasattr(settings, 'OPBEAT'):
            from opbeat.contrib.django.models import client as opbeat_client
            from opbeat.contrib.django.models import logger as opbeat_logger
            from opbeat.contrib.django.models import register_handlers as opbeat_register_handlers
            from opbeat.contrib.celery import register_signal as opbeat_register_signal

            try:
                opbeat_register_signal(opbeat_client)
            except Exception as e:
                opbeat_logger.exception('Failed installing celery hook: %s' % e)

            if 'opbeat.contrib.django' in settings.INSTALLED_APPS:
                opbeat_register_handlers() 

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 init_app(self, app: sanic.Sanic):
        self.client = raven.Client(
            dsn=app.config.get('SENTRY_DSN', None),
            transport=raven_aiohttp.AioHttpTransport,
            **app.config.get('SENTRY_PARAMS', {})
        )
        self.handler = SentryHandler(client=self.client, level=app.config.get('SENTRY_LEVEL', logging.ERROR))
        logger.addHandler(self.handler)
        self.app = app
        self.app.sentry = self 

def get_client(cls):
		if not cls.CLIENT:
			cls.CLIENT = Client(
				dsn='https://bcbafd2d81234d53b32c66077ae0a008:98dcc46acc484eeb95ebf9f0c30e6dd4@sentry.s3.toffe.me/2',
				environment='development' if settings.DEBUG else 'production',
				release=version,
				include_paths=['pyplanet']
			)
		return cls.CLIENT 

def __init__(self, dsn):
        self._client = Client(dsn=dsn, context={}) 

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 on_configure(self):
        if os.environ.get("SENTRY_DSN") is not None:
            client = raven.Client(os.environ.get("SENTRY_DSN"))
            raven_register_logger_signal(client)
            raven_register_signal(client) 

def log_exception():
    """ Log to sentry.io. Alternatively,
    fallback to stdout stacktrace dump."""
    global logger

    dsn = os.getenv('SENTRY_DSN')
    if dsn:
        import raven
        logger = raven.Client(dsn)

    if logger:
        logger.captureException()
    else:
        import traceback
        print(traceback.format_exc()) 

def on_configure(self):
        if os.environ.get('SENTRY_DSN'):
            client = raven.Client(os.environ.get('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 setup_sentry(name, channel, dsn):
    """
    Setup sentry account using taskcluster secrets
    """

    # Detect environment
    task_id = os.environ.get("TASK_ID")
    if task_id is not None:
        site = "taskcluster"
    elif "DYNO" in os.environ:
        site = "heroku"
    else:
        site = "unknown"

    sentry_client = raven.Client(
        dsn=dsn,
        site=site,
        name=name,
        environment=channel,
        release=raven.fetch_package_version(f"code-coverage-{name}"),
    )

    if task_id is not None:
        # Add a Taskcluster task id when available
        # It will be shown in the Additional Data section on the dashboard
        sentry_client.context.merge({"extra": {"task_id": task_id}})

    sentry_handler = raven.handlers.logbook.SentryHandler(
        sentry_client, level=logbook.WARNING, bubble=True
    )
    sentry_handler.push_application() 

def setup_sentry(name, channel, dsn):
    """
    Setup sentry account using taskcluster secrets
    """

    # Detect environment
    task_id = os.environ.get("TASK_ID")
    if task_id is not None:
        site = "taskcluster"
    elif "DYNO" in os.environ:
        site = "heroku"
    else:
        site = "unknown"

    sentry_client = raven.Client(
        dsn=dsn,
        site=site,
        name=name,
        environment=channel,
        release=raven.fetch_package_version(f"code-review-{name}"),
    )

    if task_id is not None:
        # Add a Taskcluster task id when available
        # It will be shown in the Additional Data section on the dashboard
        sentry_client.context.merge({"extra": {"task_id": task_id}})

    sentry_handler = raven.handlers.logbook.SentryHandler(
        sentry_client, level=logbook.WARNING, bubble=True
    )
    sentry_handler.push_application()