예제 #1
0
    def _get_event_user(self, project, data):
        user_data = data.get("sentry.interfaces.User")
        if not user_data:
            return

        euser = EventUser(
            project=project,
            ident=user_data.get("id"),
            email=user_data.get("email"),
            username=user_data.get("username"),
            ip_address=user_data.get("ip_address"),
        )

        if not euser.tag_value:
            return

        cache_key = "euser:{}:{}".format(project.id, md5(euser.tag_value.encode("utf-8")).hexdigest())
        cached = default_cache.get(cache_key)
        if cached is None:
            try:
                with transaction.atomic(using=router.db_for_write(EventUser)):
                    euser.save()
            except IntegrityError:
                pass
            default_cache.set(cache_key, "", 3600)

        return euser
예제 #2
0
def record_affected_user(event, **kwargs):
    from sentry.models import EventUser, Group

    user_data = event.data.get('sentry.interfaces.User', event.data.get('user'))
    if not user_data:
        logger.info('No user data found for event_id=%s', event.event_id)
        return

    euser = EventUser(
        project=event.project,
        ident=user_data.get('id'),
        email=user_data.get('email'),
        username=user_data.get('username'),
        ip_address=user_data.get('ip_address'),
    )

    if not euser.tag_value:
        # no ident, bail
        logger.info('No identifying value found for user on event_id=%s',
                    event.event_id)
        return

    try:
        with transaction.atomic():
            euser.save()
    except IntegrityError:
        pass

    Group.objects.add_tags(event.group, [
        ('sentry:user', euser.tag_value)
    ])
예제 #3
0
    def _get_event_user(self, project, data):
        user_data = data.get('sentry.interfaces.User')
        if not user_data:
            return

        euser = EventUser(
            project=project,
            ident=user_data.get('id'),
            email=user_data.get('email'),
            username=user_data.get('username'),
            ip_address=user_data.get('ip_address'),
        )

        if not euser.tag_value:
            return

        cache_key = 'euser:{}:{}'.format(
            project.id,
            md5_text(euser.tag_value).hexdigest(),
        )
        cached = default_cache.get(cache_key)
        if cached is None:
            try:
                with transaction.atomic(using=router.db_for_write(EventUser)):
                    euser.save()
            except IntegrityError:
                pass
            default_cache.set(cache_key, '', 3600)

        return euser
예제 #4
0
    def test_get_group_tag_values_for_users(self):
        result = self.ts.get_group_tag_values_for_users(
            [EventUser(project_id=self.proj1.id, ident='user1')])
        one_second_ago = (
            self.now -
            timedelta(seconds=1)).strftime('%Y-%m-%dT%H:%M:%S+00:00')
        assert len(result) == 1
        assert result[0].value == 'user1'
        assert result[0].last_seen == one_second_ago

        result = self.ts.get_group_tag_values_for_users(
            [EventUser(project_id=self.proj1.id, ident='user2')])
        two_seconds_ago = (
            self.now -
            timedelta(seconds=2)).strftime('%Y-%m-%dT%H:%M:%S+00:00')
        assert len(result) == 1
        assert result[0].value == 'user2'
        assert result[0].last_seen == two_seconds_ago

        # Test that users identified by different means are collected.
        # (effectively tests OR conditions in snuba API)
        result = self.ts.get_group_tag_values_for_users([
            EventUser(project_id=self.proj1.id, email='*****@*****.**'),
            EventUser(project_id=self.proj1.id, ident='user2')
        ])
        two_seconds_ago = (
            self.now -
            timedelta(seconds=2)).strftime('%Y-%m-%dT%H:%M:%S+00:00')
        assert len(result) == 2
        result.sort(key=lambda x: x.value)
        assert result[0].value == 'user1'
        assert result[0].last_seen == one_second_ago
        assert result[1].value == 'user2'
        assert result[1].last_seen == two_seconds_ago
예제 #5
0
 def test_for_tags(self):
     eu = EventUser.objects.create(project_id=1, ident="matt")
     assert EventUser.for_tags(1, ["id:matt"]) == {"id:matt": eu}
     assert EventUser.for_tags(1, ["id:doesnotexist"]) == {}
     assert EventUser.for_tags(1, ["id:matt", "id:doesnotexist"]) == {
         "id:matt": eu
     }
예제 #6
0
def record_affected_user(event, **kwargs):
    from sentry.models import EventUser, Group

    Raven.tags_context({
        'project': event.project_id,
    })

    user_data = event.data.get('sentry.interfaces.User',
                               event.data.get('user'))
    if not user_data:
        logger.info('No user data found for event_id=%s', event.event_id)
        return

    euser = EventUser(
        project=event.project,
        ident=user_data.get('id'),
        email=user_data.get('email'),
        username=user_data.get('username'),
        ip_address=user_data.get('ip_address'),
    )

    if not euser.tag_value:
        # no ident, bail
        logger.info('No identifying value found for user on event_id=%s',
                    event.event_id)
        return

    try:
        with transaction.atomic(using=router.db_for_write(EventUser)):
            euser.save()
    except IntegrityError:
        pass

    Group.objects.add_tags(event.group, [('sentry:user', euser.tag_value)])
    def test_get_group_tag_values_for_users(self):
        result = self.ts.get_group_tag_values_for_users(
            [EventUser(project_id=self.proj1.id, ident='user1')])
        assert len(result) == 2
        assert set(v.group_id for v in result) == set([
            self.proj1group1.id,
            self.proj1group2.id,
        ])
        assert set(v.last_seen for v in result) == \
            set([self.now - timedelta(seconds=1), self.now - timedelta(seconds=2)])
        result.sort(key=lambda x: x.last_seen)
        assert result[0].last_seen == self.now - timedelta(seconds=2)
        assert result[1].last_seen == self.now - timedelta(seconds=1)
        for v in result:
            assert v.value == 'user1'

        result = self.ts.get_group_tag_values_for_users(
            [EventUser(project_id=self.proj1.id, ident='user2')])
        assert len(result) == 1
        assert result[0].value == 'user2'
        assert result[0].last_seen == self.now - timedelta(seconds=2)

        # Test that users identified by different means are collected.
        # (effectively tests OR conditions in snuba API)
        result = self.ts.get_group_tag_values_for_users([
            EventUser(project_id=self.proj1.id, email='*****@*****.**'),
            EventUser(project_id=self.proj1.id, ident='user2')
        ])
        assert len(result) == 2
        result.sort(key=lambda x: x.value)
        assert result[0].value == 'user1'
        assert result[0].last_seen == self.now - timedelta(seconds=1)
        assert result[1].value == 'user2'
        assert result[1].last_seen == self.now - timedelta(seconds=2)
예제 #8
0
    def test_get_group_ids_for_users(self):
        assert self.ts.get_group_ids_for_users(
            [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user1")]
        ) == set([self.proj1group1.id, self.proj1group2.id])

        assert self.ts.get_group_ids_for_users(
            [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user2")]
        ) == set([self.proj1group1.id])
예제 #9
0
 def test_for_tags(self):
     eu = EventUser.objects.create(
         project_id=1,
         ident='matt',
     )
     assert EventUser.for_tags(1, ['id:matt']) == {'id:matt': eu}
     assert EventUser.for_tags(1, ['id:doesnotexist']) == {}
     assert EventUser.for_tags(1, ['id:matt', 'id:doesnotexist']) == {'id:matt': eu}
예제 #10
0
    def get(self, request, project):
        """
        List a Project's Users
        ``````````````````````

        Return a list of users seen within this project.

        :pparam string organization_slug: the slug of the organization.
        :pparam string project_slug: the slug of the project.
        :pparam string key: the tag key to look up.
        :auth: required
        :qparam string query: Limit results to users matching the given query.
                              Prefixes should be used to suggest the field to
                              match on: ``id``, ``email``, ``username``, ``ip``.
                              For example, ``query=email:[email protected]``
        """
        queryset = EventUser.objects.filter(project_id=project.id)
        if request.GET.get("query"):
            try:
                field, identifier = request.GET["query"].strip().split(":", 1)
            except ValueError:
                return Response([])
            # username and ip can return multiple eventuser objects
            if field in ("ip", "username"):
                queryset = queryset.filter(
                    project_id=project.id,
                    **{EventUser.attr_from_keyword(field): identifier},
                )
            else:
                try:
                    queryset = [
                        queryset.get(
                            project_id=project.id,
                            **{EventUser.attr_from_keyword(field): identifier},
                        )
                    ]
                except EventUser.DoesNotExist:
                    return Response(status=status.HTTP_404_NOT_FOUND)
                except KeyError:
                    return Response([])
                return Response(serialize(queryset, request.user))

        return self.paginate(
            request=request,
            queryset=queryset,
            order_by="-date_added",
            paginator_cls=DateTimePaginator,
            on_results=lambda x: serialize(x, request.user),
        )
예제 #11
0
파일: tagvalue.py 프로젝트: pythorn/sentry
    def get_attrs(self, item_list, user):
        users = EventUser.for_tags(project_id=item_list[0].project_id, values=[t.value for t in item_list])

        result = {}
        for item in item_list:
            result[item] = {"user": users.get(item.value)}
        return result
예제 #12
0
 def test_build_hash(self):
     cases = [
         (
             {
                 "ident": "ident",
                 "username": "******",
                 "email": "email",
                 "ip_address": "127.0.0.1",
             },
             "67217d8b401cf5e72bbf5103d60f3e97",
         ),
         (
             {
                 "username": "******",
                 "email": "email",
                 "ip_address": "127.0.0.1"
             },
             "14c4b06b824ec593239362517f538b29",
         ),
         ({
             "email": "email",
             "ip_address": "127.0.0.1"
         }, "0c83f57c786a0b4a39efab23731c7ebc"),
         ({
             "ip_address": "127.0.0.1"
         }, "f528764d624db129b32c21fbca0cb8d6"),
         ({}, None),
     ]
     for kw, value in cases:
         assert EventUser(**kw).build_hash() == value
예제 #13
0
 def test_tag_value(self):
     cases = [
         (
             {
                 "ident": "ident",
                 "username": "******",
                 "email": "email",
                 "ip_address": "127.0.0.1",
             },
             "id:ident",
         ),
         (
             {
                 "username": "******",
                 "email": "email",
                 "ip_address": "127.0.0.1"
             },
             "username:username",
         ),
         ({
             "email": "email",
             "ip_address": "127.0.0.1"
         }, "email:email"),
         ({
             "ip_address": "127.0.0.1"
         }, "ip:127.0.0.1"),
         ({}, None),
     ]
     for kw, value in cases:
         assert EventUser(**kw).tag_value == value
예제 #14
0
    def find_event_user(self, report):
        try:
            event = Event.objects.get(
                group_id=report.group_id,
                event_id=report.event_id,
            )
        except Event.DoesNotExist:
            if not report.email:
                return None
            try:
                return EventUser.objects.filter(
                    project=report.project_id,
                    email=report.email,
                )[0]
            except IndexError:
                return None

        tag = event.get_tag('sentry:user')
        if not tag:
            return None

        try:
            return EventUser.for_tags(
                project_id=report.project_id,
                values=[tag],
            )[tag]
        except KeyError:
            pass
예제 #15
0
    def find_event_user(self, report):
        try:
            event = Event.objects.get(
                group_id=report.group_id,
                event_id=report.event_id,
            )
        except Event.DoesNotExist:
            if not report.email:
                return None
            try:
                return EventUser.objects.filter(
                    project_id=report.project_id,
                    email=report.email,
                )[0]
            except IndexError:
                return None

        tag = event.get_tag('sentry:user')
        if not tag:
            return None

        try:
            return EventUser.for_tags(
                project_id=report.project_id,
                values=[tag],
            )[tag]
        except KeyError:
            pass
예제 #16
0
    def find_event_user(self, report_data):
        try:
            event = Event.objects.get(
                group_id=report_data.get('group_id'),
                event_id=report_data['event_id'],
            )
        except Event.DoesNotExist:
            if not report_data.get('email'):
                return None
            try:
                return EventUser.objects.filter(
                    project_id=report_data['project'].id,
                    email=report_data['email'],
                )[0]
            except IndexError:
                return None

        tag = event.get_tag('sentry:user')
        if not tag:
            return None

        try:
            return EventUser.for_tags(
                project_id=report_data['project'].id,
                values=[tag],
            )[tag]
        except KeyError:
            pass
예제 #17
0
def get_event_user_from_interface(value):
    return EventUser(
        ident=value.get("id"),
        email=value.get("email"),
        username=value.get("valuename"),
        ip_address=value.get("ip_address"),
    )
예제 #18
0
    def get(self, request, project):
        """
        List a Project's Users
        ``````````````````````

        Return a list of users seen within this project.

        :pparam string organization_slug: the slug of the organization.
        :pparam string project_slug: the slug of the project.
        :pparam string key: the tag key to look up.
        :auth: required
        :qparam string query: Limit results to users matching the given query.
                              Prefixes should be used to suggest the field to
                              match on: ``id``, ``email``, ``username``, ``ip``.
                              For example, ``query=email:[email protected]``
        """
        queryset = EventUser.objects.filter(project_id=project.id)
        if request.GET.get("query"):
            pieces = request.GET["query"].strip().split(":", 1)
            if len(pieces) != 2:
                return Response([])
            try:
                queryset = queryset.filter(
                    **{u"{}__icontains".format(EventUser.attr_from_keyword(pieces[0])): pieces[1]}
                )
            except KeyError:
                return Response([])

        return self.paginate(
            request=request,
            queryset=queryset,
            order_by="-date_added",
            paginator_cls=DateTimePaginator,
            on_results=lambda x: serialize(x, request.user),
        )
예제 #19
0
def get_event_user_from_interface(value):
    return EventUser(
        ident=value.get('id'),
        email=value.get('email'),
        username=value.get('valuename'),
        ip_address=value.get('ip_address'),
    )
예제 #20
0
    def get_attrs(self, item_list, user):
        user_tags = [i.value for i in item_list if i.key == 'sentry:user']

        tag_labels = {}
        if user_tags:
            tag_labels.update(
                {
                    ('sentry:user', k): v.get_label()
                    for k, v in six.iteritems(
                        EventUser.for_tags(
                            project_id=item_list[0].project_id,
                            values=user_tags,
                        )
                    )
                }
            )

        result = {}
        for item in item_list:
            try:
                label = tag_labels[(item.key, item.value)]
            except KeyError:
                label = item.get_label()
            result[item] = {
                'name': label,
            }
        return result
예제 #21
0
파일: tagvalue.py 프로젝트: liang0/sentry-1
    def get_attrs(self, item_list, user):
        users = EventUser.for_tags(project_id=self.project_id,
                                   values=[t.value for t in item_list])

        result = {}
        for item in item_list:
            result[item] = {"user": users.get(item.value)}
        return result
예제 #22
0
def get_user_tag(project, key, value):
    # TODO(dcramer): do something with case of multiple matches
    try:
        lookup = EventUser.attr_from_keyword(key)
        euser = EventUser.objects.filter(project=project, **{lookup: value})[0]
    except (KeyError, IndexError):
        return '{}:{}'.format(key, value)

    return euser.tag_value
예제 #23
0
 def test_attr_from_keyword(self):
     cases = [
         ('id', 'ident'),
         ('username', 'username'),
         ('email', 'email'),
         ('ip', 'ip_address'),
     ]
     for keyword, attr in cases:
         assert EventUser.attr_from_keyword(keyword) == attr
예제 #24
0
 def test_attr_from_keyword(self):
     cases = [
         ('id', 'ident'),
         ('username', 'username'),
         ('email', 'email'),
         ('ip', 'ip_address'),
     ]
     for keyword, attr in cases:
         assert EventUser.attr_from_keyword(keyword) == attr
예제 #25
0
 def test_attr_from_keyword(self):
     cases = [
         ("id", "ident"),
         ("username", "username"),
         ("email", "email"),
         ("ip", "ip_address"),
     ]
     for keyword, attr in cases:
         assert EventUser.attr_from_keyword(keyword) == attr
예제 #26
0
파일: utils.py 프로젝트: zhoupan/sentry
def get_user_tag(project, key, value):
    # TODO(dcramer): do something with case of multiple matches
    try:
        lookup = EventUser.attr_from_keyword(key)
        euser = EventUser.objects.filter(project=project, **{lookup: value})[0]
    except (KeyError, IndexError):
        return "{}:{}".format(key, value)

    return euser.tag_value
예제 #27
0
def _get_event_user_impl(project, data, metrics_tags):
    user_data = data.get("user")
    if not user_data:
        metrics_tags["event_has_user"] = "******"
        return

    metrics_tags["event_has_user"] = "******"

    ip_address = user_data.get("ip_address")

    if ip_address:
        try:
            ipaddress.ip_address(six.text_type(ip_address))
        except ValueError:
            ip_address = None

    euser = EventUser(
        project_id=project.id,
        ident=user_data.get("id"),
        email=user_data.get("email"),
        username=user_data.get("username"),
        ip_address=ip_address,
        name=user_data.get("name"),
    )
    euser.set_hash()
    if not euser.hash:
        return

    cache_key = u"euserid:1:{}:{}".format(project.id, euser.hash)
    euser_id = cache.get(cache_key)
    if euser_id is None:
        metrics_tags["cache_hit"] = "false"
        try:
            with transaction.atomic(using=router.db_for_write(EventUser)):
                euser.save()
            metrics_tags["created"] = "true"
        except IntegrityError:
            metrics_tags["created"] = "false"
            try:
                euser = EventUser.objects.get(project_id=project.id,
                                              hash=euser.hash)
            except EventUser.DoesNotExist:
                metrics_tags["created"] = "lol"
                # why???
                e_userid = -1
            else:
                if euser.name != (user_data.get("name") or euser.name):
                    euser.update(name=user_data["name"])
                e_userid = euser.id
            cache.set(cache_key, e_userid, 3600)
    else:
        metrics_tags["cache_hit"] = "true"

    return euser
예제 #28
0
파일: snuba.py 프로젝트: Kayle009/sentry
def serialize_eventusers(organization, item_list, user, lookup):
    if not item_list:
        return {}

    # We have no reliable way to map the tag value format
    # back into real EventUser rows. EventUser is only unique
    # per-project, and this is an organization aggregate.
    # This means a single value maps to multiple rows.
    filters = reduce(or_, [
        Q(hash=EventUser.hash_from_tag(tag), project_id=project)
        for tag, project in item_list
    ])

    eu_by_key = {
        (eu.tag_value, eu.project_id): eu
        for eu in EventUser.objects.filter(filters)
    }

    projects = serialize_projects(organization, {i[1] for i in item_list}, user)

    rv = {}
    for tag, project in item_list:
        eu = eu_by_key.get((tag, project))
        if eu is None:
            attr, value = tag.split(':', 1)
            eu = EventUser(project_id=project, **{EventUser.attr_from_keyword(attr): value})
        rv[(tag, project)] = {
            HEALTH_ID_KEY: make_health_id(lookup, [eu.tag_value, eu.project_id]),
            'value': {
                'id': six.text_type(eu.id) if eu.id else None,
                'project': projects.get(eu.project_id),
                'hash': eu.hash,
                'tagValue': eu.tag_value,
                'identifier': eu.ident,
                'username': eu.username,
                'email': eu.email,
                'ipAddress': eu.ip_address,
                'dateCreated': eu.date_added,
                'label': eu.get_label(),
                'name': eu.get_display_name(),
                'geo': geo_by_addr(eu.ip_address),
            },
        }
    return rv
예제 #29
0
def get_user_tag(project, key, value):
    # TODO(dcramer): do something with case of multiple matches
    try:
        lookup = EventUser.attr_from_keyword(key)
        euser = EventUser.objects.filter(project=project, **{lookup: value})[0]
    except (KeyError, IndexError):
        return u'{}:{}'.format(key, value)
    except DataError:
        raise InvalidQuery(u"malformed '{}:' query '{}'.".format(key, value))
    return euser.tag_value
예제 #30
0
    def test_get_group_tag_values_for_users(self):
        result = self.ts.get_group_tag_values_for_users(
            [EventUser(project_id=self.proj1.id, ident="user1")])
        assert len(result) == 2
        assert set(v.group_id for v in result) == set(
            [self.proj1group1.id, self.proj1group2.id])
        assert set(v.last_seen for v in result) == set(
            [self.now - timedelta(seconds=1), self.now - timedelta(seconds=2)])
        result.sort(key=lambda x: x.last_seen)
        assert result[0].last_seen == self.now - timedelta(seconds=2)
        assert result[1].last_seen == self.now - timedelta(seconds=1)
        for v in result:
            assert v.value == "user1"

        result = self.ts.get_group_tag_values_for_users(
            [EventUser(project_id=self.proj1.id, ident="user2")])
        assert len(result) == 1
        assert result[0].value == "user2"
        assert result[0].last_seen == self.now - timedelta(seconds=2)
예제 #31
0
파일: utils.py 프로젝트: binlee1990/sentry
def get_user_tag(project, key, value):
    # TODO(dcramer): do something with case of multiple matches
    try:
        lookup = EventUser.attr_from_keyword(key)
        euser = EventUser.objects.filter(
            project_id=project.id, **{lookup: value})[0]
    except (KeyError, IndexError):
        return u'{}:{}'.format(key, value)
    except DataError:
        raise InvalidQuery(u"malformed '{}:' query '{}'.".format(key, value))
    return euser.tag_value
예제 #32
0
    def test_get_group_tag_values_for_users(self):
        from sentry.models import EventUser

        v1, _ = self.ts.get_or_create_group_tag_value(self.proj1.id,
                                                      self.proj1group1.id,
                                                      None, 'sentry:user',
                                                      'email:[email protected]')

        eu = EventUser(project_id=self.proj1.id, email='*****@*****.**')

        assert self.ts.get_group_tag_values_for_users([eu]) == [v1]
예제 #33
0
def get_user_tag(projects, key, value):
    # TODO(dcramer): do something with case of multiple matches
    try:
        lookup = EventUser.attr_from_keyword(key)
        euser = EventUser.objects.filter(
            project_id__in=[p.id for p in projects], **{lookup: value})[0]
    except (KeyError, IndexError):
        return f"{key}:{value}"
    except DataError:
        raise InvalidQuery(f"malformed '{key}:' query '{value}'.")
    return euser.tag_value
예제 #34
0
    def test_get_group_tag_values_for_users(self):
        from sentry.models import EventUser

        v1, _ = self.ts.get_or_create_group_tag_value(self.proj1.id,
                                                      self.proj1group1.id, 0,
                                                      "sentry:user",
                                                      "email:[email protected]")

        eu = EventUser(project_id=self.proj1.id, email="*****@*****.**")

        assert self.ts.get_group_tag_values_for_users(
            [eu]) == [transformers[models.GroupTagValue](v1)]
예제 #35
0
 def test_build_hash(self):
     cases = [
         ({'ident': 'ident', 'username': '******', 'email': 'email',
           'ip_address': '127.0.0.1'}, '67217d8b401cf5e72bbf5103d60f3e97'),
         ({'username': '******', 'email': 'email', 'ip_address': '127.0.0.1'},
          '14c4b06b824ec593239362517f538b29'),
         ({'email': 'email', 'ip_address': '127.0.0.1'}, '0c83f57c786a0b4a39efab23731c7ebc'),
         ({'ip_address': '127.0.0.1'}, 'f528764d624db129b32c21fbca0cb8d6'),
         ({}, None),
     ]
     for kw, value in cases:
         assert EventUser(**kw).build_hash() == value
예제 #36
0
def get_user_tag(projects, key, value):
    # TODO(dcramer): do something with case of multiple matches
    from sentry.models import EventUser  # Django 1.9 setup issue
    try:
        lookup = EventUser.attr_from_keyword(key)
        euser = EventUser.objects.filter(
            project_id__in=[p.id for p in projects], **{lookup: value})[0]
    except (KeyError, IndexError):
        return u'{}:{}'.format(key, value)
    except DataError:
        raise InvalidQuery(u"malformed '{}:' query '{}'.".format(key, value))
    return euser.tag_value
예제 #37
0
    def get_attrs(self, item_list, user):
        users = EventUser.for_tags(
            project_id=item_list[0].project_id,
            values=[t.value for t in item_list],
        )

        result = {}
        for item in item_list:
            result[item] = {
                'user': users.get(item.value),
            }
        return result
예제 #38
0
파일: tagvalue.py 프로젝트: Kayle009/sentry
    def get_attrs(self, item_list, user):
        users = EventUser.for_tags(
            project_id=self.project_id,
            values=[t.value for t in item_list],
        )

        result = {}
        for item in item_list:
            result[item] = {
                'user': users.get(item.value),
            }
        return result
예제 #39
0
    def test_get_group_ids_for_users(self):
        from sentry.models import EventUser

        v1, _ = self.ts.get_or_create_group_tag_value(self.proj1.id,
                                                      self.proj1group1.id, 0,
                                                      "sentry:user",
                                                      "email:[email protected]")

        eu = EventUser(project_id=self.proj1.id, email="*****@*****.**")

        assert self.ts.get_group_ids_for_users([self.proj1.id], [eu]) == set(
            [self.proj1group1.id])
예제 #40
0
    def _get_event_user(self, project, data):
        user_data = data.get('sentry.interfaces.User')
        if not user_data:
            return

        euser = EventUser(
            project=project,
            ident=user_data.get('id'),
            email=user_data.get('email'),
            username=user_data.get('username'),
            ip_address=user_data.get('ip_address'),
        )

        if not euser.tag_value:
            return

        try:
            with transaction.atomic():
                euser.save()
        except IntegrityError:
            pass

        return euser
예제 #41
0
파일: tagvalue.py 프로젝트: pythorn/sentry
    def get_attrs(self, item_list, user):
        user_tags = [i.value for i in item_list if i.key == "sentry:user"]

        tag_labels = {}
        if user_tags:
            tag_labels.update(
                {
                    ("sentry:user", k): v.get_label()
                    for k, v in six.iteritems(EventUser.for_tags(project_id=item_list[0].project_id, values=user_tags))
                }
            )

        result = {}
        for item in item_list:
            try:
                label = tag_labels[(item.key, item.value)]
            except KeyError:
                label = item.get_label()
            result[item] = {"name": label}
        return result
예제 #42
0
    def _get_event_user(self, project, data):
        user_data = data.get('sentry.interfaces.User')
        if not user_data:
            return

        euser = EventUser(
            project_id=project.id,
            ident=user_data.get('id'),
            email=user_data.get('email'),
            username=user_data.get('username'),
            ip_address=user_data.get('ip_address'),
            name=user_data.get('name'),
        )
        euser.set_hash()
        if not euser.hash:
            return

        cache_key = 'euserid:1:{}:{}'.format(
            project.id,
            euser.hash,
        )
        euser_id = default_cache.get(cache_key)
        if euser_id is None:
            try:
                with transaction.atomic(using=router.db_for_write(EventUser)):
                    euser.save()
            except IntegrityError:
                try:
                    euser = EventUser.objects.get(
                        project_id=project.id,
                        hash=euser.hash,
                    )
                except EventUser.DoesNotExist:
                    # why???
                    e_userid = -1
                else:
                    if euser.name != (user_data.get('name') or euser.name):
                        euser.update(
                            name=user_data['name'],
                        )
                    e_userid = euser.id
                default_cache.set(cache_key, e_userid, 3600)
        return euser
예제 #43
0
    def get(self, request, project):
        """
        List a Project's Users
        ``````````````````````

        Return a list of users seen within this project.

        :pparam string organization_slug: the slug of the organization.
        :pparam string project_slug: the slug of the project.
        :pparam string key: the tag key to look up.
        :auth: required
        :qparam string query: Limit results to users matching the given query.
                              Prefixes should be used to suggest the field to
                              match on: ``id``, ``email``, ``username``, ``ip``.
                              For example, ``query=email:[email protected]``
        """
        queryset = EventUser.objects.filter(
            project_id=project.id,
        )
        if request.GET.get('query'):
            pieces = request.GET['query'].strip().split(':', 1)
            if len(pieces) != 2:
                return Response([])
            try:
                queryset = queryset.filter(
                    **{u'{}__icontains'.format(EventUser.attr_from_keyword(pieces[0])): pieces[1]}
                )
            except KeyError:
                return Response([])

        return self.paginate(
            request=request,
            queryset=queryset,
            order_by='-date_added',
            paginator_cls=DateTimePaginator,
            on_results=lambda x: serialize(x, request.user),
        )
예제 #44
0
 def test_hash_from_tag(self):
     assert EventUser.hash_from_tag('foo:bar:baz') == md5('bar:baz').hexdigest()
예제 #45
0
 def wrapped(items):
     users = EventUser.for_tags(project_id, [i.value for i in items])
     for item in items:
         item._eventuser = users.get(item.value)