Example #1
0
File: views.py Project: dmr/sentry
def index():
    all_slices = list(slices.all())

    if len(all_slices) == 1:
        return redirect(url_for('view_slice', slug=all_slices[0].slug))

    # Render dashboard
    return render_template('sentry/dashboard.html', {
        'slices': all_slices,
    })
Example #2
0
File: base.py Project: dmr/sentry
    def store(self, event_type, tags, data, date, time_spent, event_id, **kwargs):
        module, class_name = event_type.rsplit('.', 1)

        handler = getattr(__import__(module, {}, {}, [class_name], -1), class_name)()
        
        # Grab our tags for this event
        for k, v in tags:
            # XXX: this should be cached
            tag_hash = hashlib.md5('%s=%s' % (k, v)).hexdigest()
            tag, created = Tag.objects.get_or_create(
                hash=tag_hash,
                defaults={
                    'key': k,
                    'value': v,
                    'count': 1,
                })
            # Maintain counts
            if not created:
                tag.incr('count')

        # TODO: this should be generated from the TypeProcessor
        event_hash = hashlib.md5('|'.join(k or '' for k in handler.get_event_hash(**data['__event__']))).hexdigest()

        event = Event.objects.create(
            pk=event_id,
            type=event_type,
            hash=event_hash,
            date=date,
            time_spent=time_spent,
            tags=tags,
        )
        event.set_meta(**data)

        event_message = handler.to_string(event, data.get('__event__'))

        groups = []

        # For each view that handles this event, we need to create a Group
        for slice_ in slices.all():
            if slice_.is_valid_event(event_type):
                # # We only care about tags which are required for this view
                # event_tags = [(k, v) for k, v in tags if k in view.get('tags', [])]
                # tags_hash = TagCount.get_tags_hash(event_tags)
                # 
                # # Handle TagCount creation and incrementing
                # tc, created = TagCount.objects.get_or_create(
                #     hash=tags_hash,
                #     defaults={
                #         'tags': event_tags,
                #         'count': 1,
                #     }
                # )
                # if not created:
                #     tc.incr('count')

                group_message = event_message
                # if not view.get('labelby'):
                #     group_message = event_message
                # else:
                #     # TODO:
                group, created = Group.objects.get_or_create(
                    type=event_type,
                    hash=slice_.id + event_hash,
                    defaults={
                        'count': 1,
                        'time_spent': time_spent or 0,
                        'tags': tags,
                        'message': group_message,
                    }
                )
                if not created:
                    group.incr('count')
                    if time_spent:
                        group.incr('time_spent', time_spent)

                group.update(last_seen=event.date, score=group.get_score())

                group.add_relation(event, date.strftime('%s.%m'))

                groups.append(group)

        return event, groups