Python Client.capture方法代码示例

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
class PyLogConf (PyLog):
    def __init__ (self, conf):
        """
        Initialize object based on the provided configuration
        """
        self.conf = conf
        self.client = Client (conf.RAVEN['dsn'])
        self.formatters = {}
        for k,v in self.conf.FILE_FORMATTERS.iteritems():
            if isinstance(v,str):
                raise ValueError ('Please use a list or a tuple for the file formatters values')
            self.formatters[k] = [item_import(i)() for i in v]
        dbname = os.path.join(os.path.dirname(conf.__file__),'pylogwatch.db')
        return super(PyLogConf, self).__init__ (self.conf.FILE_FORMATTERS.keys(), dbname = dbname)

    def process_lines (self, fname, fileobject, lines):
        """Main workhorse. Called with the filename that is being logged and an iterable of lines"""
        for line in lines:
            paramdict = {}
            data = {'event_type':'Message', 'message': line.replace('%','%%'), 'data' :{'logger':fname}}
            for fobj in self.formatters[fname]:
                fobj.format_line(line, data, paramdict)
            if not data.pop('_do_not_send', False): # Skip lines that have the '_do_not_send' key
                if paramdict:
                    data['params'] = tuple([paramdict[i] for i in sorted(paramdict.keys())])
                if self.conf.DEBUG:
                    print data
                self.client.capture(**data)
                self.update_bytes(fname, fileobject.tell())

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
class PyLogConf (PyLog):
    def __init__ (self, conf):
        self.conf = conf
        self.client = Client (conf.RAVEN['dsn'])
        self.formatters = {}
        for k,v in self.conf.FILE_FORMATTERS.iteritems():
            if isinstance(v,str):
                raise ValueError ('Please use a list or a tuple for the file formatters values')
            self.formatters[k] = [item_import(i)() for i in v]
        dbname = os.path.join(os.path.dirname(conf.__file__),'pylogwatch.db')
        return super(PyLogConf, self).__init__ (self.conf.FILE_FORMATTERS.keys(), dbname = dbname)

    def get_file_signature(self, fname):
        maxcount = 10
        count = 0
        result = []
        with open(fname) as f:
            while count < maxcount:
                result.append(f.readline())
                count+=1
        return result

    def process_lines (self, fname, lines):
        for line in lines:
            paramdict = {}
            data = {'event_type':'Message', 'message': line.replace('%','%%'), 'data' :{'logger':fname}}
            for fobj in self.formatters[fname]:
                fobj.format_line(line, data, paramdict)
            if not data.get('do_not_send', False):
                if paramdict:
                    data['params'] = tuple([paramdict[i] for i in sorted(paramdict.keys())])
                if self.conf.DEBUG:
                    print data
                self.client.capture(**data)

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
 def save(self, *a, **k):
     """
     Don't save to the database, send to sentry instead.
     """
     log_level = self.log_level
     filename = get_filename(self.js_url)
     
     data={
         filename: {
             'url': self.js_url,
             'data': {},
             'query_string': '...',
             'method': 'POST',
         },
         'logger': 'front_end',
         'site': 'site.name',
     }
     
     if self.extra:
         data.update({"extra": json.loads(self.extra)})
             
     client = Client(settings.SENTRY_DSN)
     client.capture(
         "Message",
         message=self.message,
         data=data,
     )

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
 def send_to_sentry(self):
     """
     Send this error to sentry where it will be stored and aggregated.
     """
     print self.stack_trace
     log_level = self.log_level
     filename = get_filename(self.js_url)
     
     data={
         filename: {
             'url': self.js_url,
             'data': {},
             'query_string': '...',
             'method': 'POST',
         },
         'logger': 'front_end',
         'site': 'site.name',
     }
     
     if self.extra:
         data.update({"extra": json.loads(self.extra)})
             
     client = Client(settings.SENTRY_DSN)
     client.capture(
         "Message",
         message=self.message,
         data=data,
     )

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def process(self, record):
        if match_record(self.rules_tree, record):
            dsn = self.dsns.get(record.application)
            if dsn is None:
                projects = requests.get("%s/api/0/projects/" % self.url,
                                        auth=self.auth).json()
                for project in projects:
                    if project["name"] == record.application:
                        break
                else:
                    project = requests.post("%s/api/0/teams/%s/%s/projects/" % (self.url,
                                                                                self.organization,
                                                                                self.team),
                                            auth=self.auth,
                                            headers={"Content-type": "application/json"},
                                            data=json.dumps({"name": record.application})).json()

                for key in requests.get("%s/api/0/projects/%s/%s/keys/" % (self.url,
                                                                           self.organization,
                                                                           project["slug"]),
                                        auth=self.auth).json():
                    dsn = key["dsn"]["secret"]
                    self.dsns[record.application] = dsn

            client = Client(dsn, raise_send_errors=True)
            client.capture("raven.events.Message",
                           message=record.msg,
                           formatted=record.explanation or record.msg,
                           data={"logger": record.logger},
                           date=record.datetime,
                           extra=record._asdict())

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
class SentryEmailProcessor(object):
    NAME = "sentry"
    EMAIL_SUBJECT_IDENTIFIER = "sentry"

    def __init__(self, config):
        self.client = Client(config['sentry_dsn'])
        self.validation_key = config['email_body_validation_key']

    def process(self, message):
        """Takes a mail message, parses the relevant part, and sends the parsed
        data to Sentry using the Raven client.

        The message must be a multipart message with a 'text/plain' part. This 'text/plain'
        part must begin with the correct sentry validation key, followed by json data.
        If the message is not in this format, it will be dropped."""

        raised = False

        # If message is multipart we only want the text version of the body,
        # this walks the message and gets the body.
        # multipart means dual html and text representations
        if message.get_content_maintype() == 'multipart':
            for part in message.walk():
                if part.get_content_type() == "text/plain":
                    body = part.get_payload(decode=True)
                    # Check if this is the relevant part of the message
                    if body.startswith(self.validation_key):
                        json_ = self.parse_json_message(body[self.validation_key.__len__()+1:])
                        self.raise_to_sentry(json_)
                        raised = True
                        break
        if not raised:
            log.warning("Message is not in the correct format to be processed by SentryEmailProcessor, even though it's subject line indicates that it ought to be. Dropping mail.")

    def raise_to_sentry(self, jsondata):
        try:
            event_date = dateutil.parser.parse(jsondata['date'])
        except Exception:
            event_date = datetime.utcnow()

        event_data = jsondata['data']
        event_data['server_name'] = jsondata['server_name']

        self.client.capture('Exception', message = jsondata['message'], date = event_date, data = event_data)

    def parse_json_message(self, text):
        text = text.replace('\r\n ', '\n')
        text = text.replace('\n', '')
        parsed_data = json.loads(text)
        return parsed_data

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def test_basic(self, send_remote):
        send_remote.side_effect = self.sendRemote
        client = Client(
            project=settings.PROJECT,
            servers=['http://localhost:8000%s' % reverse('sentry-api-store')],
            key=settings.KEY,
        )
        client.capture('Message', message='foo')

        self.assertEquals(Group.objects.count(), 1)
        group = Group.objects.get()
        self.assertEquals(group.event_set.count(), 1)
        instance = group.event_set.get()
        self.assertEquals(instance.message, 'foo')

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def test_basic(self, send_remote):
        send_remote.side_effect = self.sendRemote
        client = Client(
            dsn='http://%s:%[email protected]:8000/%s' % (
                self.pk.public_key, self.pk.secret_key, self.pk.project_id)
        )
        client.capture('Message', message='foo')

        send_remote.assert_called_once()
        self.assertEquals(Group.objects.count(), 1)
        group = Group.objects.get()
        self.assertEquals(group.event_set.count(), 1)
        instance = group.event_set.get()
        self.assertEquals(instance.message, 'foo')

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def test_basic(self, send_remote):
        send_remote.side_effect = self.sendRemote
        client = Client(
            dsn="http://%s:%[email protected]:8000/%s" % (self.pk.public_key, self.pk.secret_key, self.pk.project_id)
        )

        with self.tasks():
            client.capture("Message", message="foo")

        send_remote.assert_called_once()
        assert Group.objects.count() == 1
        group = Group.objects.get()
        assert group.event_set.count() == 1
        instance = group.event_set.get()
        assert instance.message == "foo"

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def connect_sentry(message, result):
        '''
        Connect to the Sentry server
        '''
        pillar_data = __salt__['pillar.raw']()
        grains = __salt__['grains.items']()
        sentry_data = {
            'result': result,
            'pillar': pillar_data,
            'grains': grains
        }
        data = {
            'platform': 'python',
            'culprit': ret['fun'],
            'level': 'error'
        }
        tags = {}
        if 'tags' in pillar_data['raven']:
            for tag in pillar_data['raven']['tags']:
                tags[tag] = grains[tag]

        if ret['return']:
            data['level'] = 'info'

        servers = []
        try:
            for server in pillar_data['raven']['servers']:
                servers.append(server + '/api/store/')
            client = Client(
                servers=servers,
                public_key=pillar_data['raven']['public_key'],
                secret_key=pillar_data['raven']['secret_key'],
                project=pillar_data['raven']['project'],
            )
        except KeyError as missing_key:
            logger.error(
                'Sentry returner need config {0!r} in pillar'.format(
                    missing_key
                )
            )
        else:
            try:
                client.capture('raven.events.Message', message=message, data=data, extra=sentry_data, tags=tags)
            except Exception as err:
                logger.error(
                    'Can\'t send message to sentry: {0}'.format(err),
                    exc_info=True
                )

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def test_basic(self, send_remote):
        send_remote.side_effect = self.sendRemote
        client = Client(
            project=self.pk.project_id,
            servers=['http://localhost:8000%s' % reverse('sentry-api-store', args=[self.pk.project_id])],
            public_key=self.pk.public_key,
            secret_key=self.pk.secret_key,
        )
        client.capture('Message', message='foo')

        send_remote.assert_called_once()
        self.assertEquals(Group.objects.count(), 1)
        group = Group.objects.get()
        self.assertEquals(group.event_set.count(), 1)
        instance = group.event_set.get()
        self.assertEquals(instance.message, 'foo')

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def test_basic(self, send_remote):
        send_remote.side_effect = self.sendRemote
        client = Client(
            dsn='http://%s:%[email protected]:8000/%s' % (
                self.pk.public_key, self.pk.secret_key, self.pk.project_id)
        )

        with self.tasks():
            client.capture('Message', message='foo')

        assert send_remote.call_count is 1
        assert Group.objects.count() == 1
        group = Group.objects.get()
        assert group.event_set.count() == 1
        instance = group.event_set.get()
        assert instance.message == 'foo'

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
def send_message(message, params, site, logger,
        interface_type="sentry.interfaces.Message",
        log_level=logging.ERROR, sentry_dsn=None):
    data={
        'site': site,
        'logger': logger,
    }

    if sentry_dsn:
        client = Client(dsn=sentry_dsn)
    else:
        raise Exception("No Sentry DSN")

    if "request" in params.keys():
        interface_type = "sentry.interfaces.Http"
        data[interface_type] = params["request"]
    else:
        data[interface_type] = message
    
    if params["QueryObject"] and params["QueryObject"] != "-":
        tags = params["QueryObject"]
    else:
        tags = None
        
    if params["urlpath"] and params["urlpath"] != "-":
        if not tags:
            tags = {}
        tags["UrlPath"] = params["urlpath"]
    
    if params["ip"] and params["ip"] != "-":
        if not tags:
            tags = {}
        tags["UserIP"] = params["ip"]
    
    date = datetime.datetime.strptime("%s %s" % (params["date"],params["time"]), "%Y/%b/%d %H:%M:%S")
    
    subject = message.get("message", message.get("url", "Unknown Message"))

    client.capture(
        'Message',
        message=subject,
        data=data,
        level=log_level,
        extra=params,
        tags=tags,
        date=date
    )

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
    def connect_sentry(message, result):
        '''
        Connect to the Sentry server
        '''
        pillar_data = __salt__['pillar.raw']()
        grains = __salt__['grains.items']()
        raven_config = pillar_data['raven']
        hide_pillar = raven_config.get('hide_pillar')
        sentry_data = {
            'result': result,
            'pillar': 'HIDDEN' if hide_pillar else pillar_data,
            'grains': grains
        }
        data = {
            'platform': 'python',
            'culprit': message,
            'level': 'error'
        }
        tags = {}
        if 'tags' in raven_config:
            for tag in raven_config['tags']:
                tags[tag] = grains[tag]

        if ret_is_not_error(ret):
            data['level'] = 'info'

        if raven_config.get('report_errors_only') and data['level'] != 'error':
            return

        if raven_config.get('dsn'):
            client = Client(raven_config.get('dsn'), transport=HTTPTransport)
        else:
            try:
                servers = []
                for server in raven_config['servers']:
                    servers.append(server + '/api/store/')
                client = Client(
                    servers=servers,
                    public_key=raven_config['public_key'],
                    secret_key=raven_config['secret_key'],
                    project=raven_config['project'],
                    transport=HTTPTransport
                )
            except KeyError as missing_key:
                logger.error(
                    'Sentry returner needs key \'%s\' in pillar',
                    missing_key
                )
                return

        try:
            msgid = client.capture('raven.events.Message', message=message, data=data, extra=sentry_data, tags=tags)
            logger.info('Message id %s written to sentry', msgid)
        except Exception as exc:
            logger.error(
                'Can\'t send message to sentry: {0}'.format(exc),
                exc_info=True
            )

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import capture [as 别名]
def returner(ret):
    """
    If an error occurs, log it to sentry
    """

    if not ret['success']:
        logger.debug("not a success, do something")
        try:
            pillar_data = __salt__['pillar.data']()
            logger.error(pillar_data)
            client = Client(
                servers=pillar_data['raven']['servers'],
                public_key=pillar_data['raven']['public_key'],
                secret_key=pillar_data['raven']['secret_key'],
                project=pillar_data['raven']['project'],
                )
            client.capture('Salt state failure', data=ret)
        except Exception, err:
            logger.error("Can't init client: %s", err, exc_info=True)