Python client.captureMessage函数代码示例

def csp_violation_capture(request):
    # HT @glogiotatidis https://github.com/mozmar/lumbergh/pull/180/
    if not settings.CSP_REPORT_ENABLE:
        # mitigation option for a flood of violation reports
        return HttpResponse()

    data = client.get_data_from_request(request)
    data.update({
        'level': logging.INFO,
        'logger': 'CSP',
    })
    try:
        csp_data = json.loads(request.body.decode())
    except ValueError:
        # Cannot decode CSP violation data, ignore
        return HttpResponseBadRequest('Invalid CSP Report')

    try:
        blocked_uri = csp_data['csp-report']['blocked-uri']
    except KeyError:
        # Incomplete CSP report
        return HttpResponseBadRequest('Incomplete CSP Report')

    client.captureMessage(message='CSP Violation: {}'.format(blocked_uri),
                          data=data)

    return HttpResponse('Captured CSP violation, thanks for reporting.')

    def test_simple(self):
        assert client.__class__ is SentryInternalClient

        with self.settings(CELERY_ALWAYS_EAGER=True):
            client.captureMessage('internal client test')

        event = Event.objects.get()
        assert event.message == 'internal client test'

    def test_simple(self):
        assert client.__class__ is SentryInternalClient

        with self.tasks():
            client.captureMessage('internal client test')

        event = Event.objects.get()
        assert event.message == 'internal client test'

    def test_simple(self, send):
        assert client.__class__ is SentryInternalClient

        with self.tasks():
            client.captureMessage("internal client test")

        event = Event.objects.get()
        assert event.data["sentry.interfaces.Message"]["message"] == "internal client test"
        assert send.call_count == 0

    def test_simple(self, send):
        assert client.__class__ is SentryInternalClient

        with self.tasks():
            client.captureMessage('internal client test')

        event = Event.objects.get()
        assert event.data['sentry.interfaces.Message']['message'] == \
            'internal client test'
        assert send.call_count == 0

    def test_upstream(self, send):
        with self.dsn('http://foo:[email protected]/1'):
            with self.options({'sentry:install-id': 'abc123'}):
                with self.tasks():
                    client.captureMessage('internal client test')

                event = Event.objects.get()
                assert event.message == 'internal client test'

                # Make sure that the event also got sent upstream
                assert send.call_count == 1
                _, kwargs = send.call_args
                # and got tagged properly
                assert kwargs['tags']['install-id'] == 'abc123'

    def test_upstream(self, send):
        with self.dsn("http://foo:[email protected]e.com/1"):
            with self.options({"sentry:install-id": "abc123"}):
                with self.tasks():
                    client.captureMessage("internal client test")

                event = Event.objects.get()
                assert event.data["sentry.interfaces.Message"]["message"] == "internal client test"

                # Make sure that the event also got sent upstream
                assert send.call_count == 1
                _, kwargs = send.call_args
                # and got tagged properly
                assert kwargs["tags"]["install-id"] == "abc123"

def check_reporting(app_configs, **kwargs):
    errors = []

    current_user = pwd.getpwuid(os.getuid()).pw_name

    # Get all configs if we don't get a specific set
    if not app_configs:
        app_configs = apps.apps.app_configs.values()

    raven_installed = bool(list(filter(lambda app: app.name == "raven.contrib.django.raven_compat", app_configs)))
    if not raven_installed:
        errors.append(W001)
    else:
        raven_config = getattr(settings, 'RAVEN_CONFIG', None)
        if raven_config is None or not isinstance(raven_config, dict):
            errors.append(E001)

        try:
            # noinspection PyPackageRequirements,PyUnresolvedReferences
            from raven.contrib.django.models import client

            # So we are duplicating code from manage.py raven test here...

            if not all([client.servers, client.project, client.public_key, client.secret_key]):
                errors.append(E002)

            if not client.is_enabled():
                errors.append(E003)
            else:
                # Test sending
                data = {
                    'culprit': 'preflight.checks.check_reporting',
                    'logger': 'raven.test',
                    'request': {
                        'method': 'GET',
                        'url': 'http://example.com',
                    }
                }
                ident = client.get_ident(client.captureMessage(
                    message='This is a test message generated using ``raven test``',
                    data=data,
                    level=logging.INFO,
                    stack=True,
                    tags={},
                    extra={
                        'user': current_user,
                        'loadavg': os.getloadavg(),
                    },
                ))

                if client.state.did_fail():
                    errors.append(E004)

        except ImportError:
            errors.append(E005)

    # TODO: check if we actually log something

    return errors

    def test_simple(self, send):
        assert client.__class__ is SentryInternalClient

        with self.tasks():
            event_id = client.captureMessage('internal client test')

        event = Event.objects.get()
        assert event.project_id == settings.SENTRY_PROJECT
        assert event.event_id == event_id
        assert event.data['sentry.interfaces.Message']['message'] == \
            'internal client test'
        assert send.call_count == 0

def csp_violation_capture(request):
    data = sentry_client.get_data_from_request(request)
    data.update({
        'level': logging.INFO,
        'logger': 'CSP',
    })
    try:
        csp_data = json.loads(request.body)
    except ValueError:
        # Cannot decode CSP violation data, ignore
        return HttpResponseBadRequest('Invalid CSP Report')

    try:
        blocked_uri = csp_data['csp-report']['blocked-uri']
    except KeyError:
        # Incomplete CSP report
        return HttpResponseBadRequest('Incomplete CSP Report')

    sentry_client.captureMessage(
        message='CSP Violation: {}'.format(blocked_uri),
        data=data)

    return HttpResponse('Captured CSP violation, thanks for reporting.')

 def process_response(self, request, response):
     if response.status_code != 404 or _is_ignorable_404(request.get_full_path()):
         return response
     data = client.get_data_from_request(request)
     data.update({
         'level': logging.INFO,
         'logger': 'http404',
     })
     result = client.captureMessage(message='Page Not Found: %s' % request.build_absolute_uri(), data=data)
     request.sentry = {
         'project_id': data.get('project', client.project),
         'id': client.get_ident(result),
     }
     return response

    def test_upstream(self, send):
        with self.dsn('http://foo:[email protected]/1'):
            with self.options({'sentry:install-id': 'abc123'}):
                with self.tasks():
                    event_id = client.captureMessage('internal client test')

                event = Event.objects.get()
                assert event.project_id == settings.SENTRY_PROJECT
                assert event.event_id == event_id
                assert event.data['sentry.interfaces.Message']['message'] == \
                    'internal client test'

                # Make sure that the event also got sent upstream
                assert send.call_count == 1
                _, kwargs = send.call_args
                # and got tagged properly
                assert kwargs['tags']['install-id'] == 'abc123'

 def test_basic(self, captureMessage):
     client.captureMessage(message='foo')
     captureMessage.assert_called_once_with(message='foo')

def capture_event(request):
    client.captureMessage('test')
    return HttpResponse('')

    def handle(self, *args, **options):
        jobs_added = 0
        jobs_updated = 0
        jobs_removed = 0
        job_ids = []

        response = requests.get(GREENHOUSE_URL.format(settings.GREENHOUSE_BOARD_TOKEN))
        response.raise_for_status()

        data = response.json()
        for job in data['jobs']:
            # Maybe GH sometimes includes jobs with the same ID multiple times
            # in the json. Capture the event in Sentry and look the other way.
            if job['id'] in job_ids:
                client.captureMessage(
                        message='[GH Sync] Job {} twice in the same json'.format(job['id']),
                        data={'extra': {'jobs': data['jobs']}})
                continue

            job_ids.append(job['id'])

            job_object, created = (Position.objects
                                   .get_or_create(job_id=job['id'], source='gh'))

            departments = job.get('departments', '')
            if departments:
                department = departments[0]['name'] or ''
            else:
                department = ''

            offices = job.get('offices', '')
            if offices:
                location = ','.join([office['name'] for office in offices])
            else:
                location = ''

            description = H.unescape(job.get('content', ''))
            description = cleaner.clean(description)
            # Remove empty paragraphs and h4s and paragraphs with \xa0
            # (no-brake space). I ♥ regex
            description = re.sub(r'<(p|h4)>([ ]*|(\xa0)+)</(p|h4)>', '', description)

            for metadata in job.get('metadata', []):
                if metadata.get('name', '') == 'Employment Type':
                    position_type = metadata['value'] or ''
                    break
            else:
                position_type = ''

            object_data = {
                'title': job['title'],
                'department': department,
                'location': location,
                'description': description,
                'position_type': position_type,
                'apply_url': job['absolute_url'],
            }

            changed = False
            for key, value in object_data.items():
                if getattr(job_object, key, None) != value:
                    changed = True
                    setattr(job_object, key, value)

            if changed:
                if created:
                    jobs_added += 1
                else:
                    jobs_updated += 1
                job_object.save()

        positions_to_be_removed = Position.objects.exclude(job_id__in=job_ids, source='gh')
        jobs_removed = positions_to_be_removed.count()
        positions_to_be_removed.delete()

        self.stdout.write(
            'Jobs added: {added} updated: {updated} '
            'removed: {removed}'.format(added=jobs_added,
                                        updated=jobs_updated,
                                        removed=jobs_removed))