Пример #1
0
    def poll(request):
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.all()

        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        elif sort == 'freq':
            message_list = message_list.order_by('-times_seen')
        else:
            sort = 'priority'
            message_list = message_list.order_by('-score', '-last_seen')

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [(m.pk, {
            'html':
            render_to_string('sentry/partial/_group.html', {
                'group': m,
                'priority': p,
                'request': request,
            }).strip(),
            'title':
            m.view or m.message_top(),
            'message':
            m.error(),
            'level':
            m.get_level_display(),
            'logger':
            m.logger,
            'count':
            m.times_seen,
            'priority':
            p,
        }) for m, p in with_priority(message_list[0:15])]

        response = HttpResponse(json.dumps(data))
        response['Content-Type'] = 'application/json'
        return response
Пример #2
0
    def poll(request):
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.all()

        sort = request.GET.get("sort")
        if sort == "date":
            message_list = message_list.order_by("-last_seen")
        elif sort == "new":
            message_list = message_list.order_by("-first_seen")
        elif sort == "freq":
            message_list = message_list.order_by("-times_seen")
        else:
            sort = "priority"
            message_list = message_list.order_by("-score", "-last_seen")

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [
            (
                m.pk,
                {
                    "html": render_to_string(
                        "sentry/partial/_group.html", {"group": m, "priority": p, "request": request}
                    ).strip(),
                    "title": m.view or m.message_top(),
                    "message": m.error(),
                    "level": m.get_level_display(),
                    "logger": m.logger,
                    "count": m.times_seen,
                    "priority": p,
                },
            )
            for m, p in with_priority(message_list[0:15])
        ]

        response = HttpResponse(json.dumps(data))
        response["Content-Type"] = "application/json"
        return response
Пример #3
0
    def poll(request):
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.all()
        
        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        elif sort == 'freq':
            message_list = message_list.order_by('-times_seen')
        else:
            sort = 'priority'
            message_list = message_list.order_by('-score', '-last_seen')
        
        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)
        
        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'priority': p,
                    'request': request,
                }).strip(),
                'title': m.view or m.message_top(),
                'message': m.error(),
                'level': m.get_level_display(),
                'logger': m.logger,
                'count': m.times_seen,
                'priority': p,
            }) for m, p in with_priority(message_list[0:15])]
        
        response = HttpResponse(json.dumps(data))
        response['Content-Type'] = 'application/json'
        return response
Пример #4
0
def ajax_handler(request):
    op = request.REQUEST.get('op')
    if op == 'poll':
        message_list = GroupedMessage.objects.extra(
            select={
                'score': GroupedMessage.get_score_clause(),
            }
        ).order_by('-score', '-last_seen')
        
        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {'group': m, 'priority': p}),
                'count': m.times_seen,
                'priority': p,
            }) for m, p in with_priority(message_list[0:15])]

    elif op == 'resolve':
        gid = request.REQUEST.get('gid')
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()
        
        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1
        
        if not request.is_ajax():
            return HttpResponseRedirect(request.META['HTTP_REFERER'])
        
        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {'group': m}),
                'count': m.times_seen,
            }) for m in [group]]
        
    response = HttpResponse(simplejson.dumps(data))
    response['Content-Type'] = 'application/json'
    return response
Пример #5
0
def ajax_handler(request):
    op = request.REQUEST.get('op')

    if op == 'notification':
        return render_to_response('sentry/partial/_notification.html',
                                  request.GET,
                                  context_instance=RequestContext(request))
    elif op == 'poll':
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        query = request.GET.get('content')
        is_search = query

        if is_search:
            message_list = get_search_query_set(query)
        else:
            message_list = GroupedMessage.objects.extra(
                select={
                    'score': GroupedMessage.get_score_clause(),
                }
            )
            if query:
                # You really shouldnt be doing this
                message_list = message_list.filter(
                    Q(view__icontains=query) \
                    | Q(message__icontains=query) \
                    | Q(traceback__icontains=query)
                )
        
        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        else:
            sort = 'priority'
            if not is_search:
                message_list = message_list.order_by('-score', '-last_seen')

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'priority': p,
                    'request': request,
                }).strip(),
                'title': m.view or m.message_top(),
                'message': m.error(),
                'level': m.get_level_display(),
                'logger': m.logger,
                'count': m.times_seen,
                'priority': p,
            }) for m, p in with_priority(message_list[0:15])]

    elif op == 'resolve':
        gid = request.REQUEST.get('gid')
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(request.META['HTTP_REFERER'])

        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'request': request,
                }).strip(),
                'count': m.times_seen,
            }) for m in [group]]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(simplejson.dumps(data))
    response['Content-Type'] = 'application/json'
    return response
Пример #6
0
def ajax_handler(request):
    op = request.REQUEST.get("op")

    if op == "poll":
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.extra(select={"score": GroupedMessage.get_score_clause()})

        sort = request.GET.get("sort")
        if sort == "date":
            message_list = message_list.order_by("-last_seen")
        elif sort == "new":
            message_list = message_list.order_by("-first_seen")
        else:
            sort = "priority"
            message_list = message_list.order_by("-score", "-last_seen")

        query = Q()
        for filter_ in filters:
            if not filter_.is_set():
                continue
            any_filter = True
            query &= filter_._get_query()
        message_list = message_list.filter(query).distinct()

        data = [
            (
                m.pk,
                {
                    "html": render_to_string(
                        "sentry/partial/_group.html", {"group": m, "priority": p, "request": request}
                    ),
                    "count": m.times_seen,
                    "priority": p,
                },
            )
            for m, p in with_priority(message_list[0:15])
        ]

    elif op == "resolve":
        gid = request.REQUEST.get("gid")
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(request.META["HTTP_REFERER"])

        data = [
            (
                m.pk,
                {
                    "html": render_to_string("sentry/partial/_group.html", {"group": m, "request": request}),
                    "count": m.times_seen,
                },
            )
            for m in [group]
        ]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(simplejson.dumps(data))
    response["Content-Type"] = "application/json"
    return response
Пример #7
0
def ajax_handler(request):
    op = request.REQUEST.get("op")
    if op == "poll":
        logger_names = SortedDict((l, l) for l in GroupedMessage.objects.values_list("logger", flat=True).distinct())
        server_names = SortedDict((l, l) for l in Message.objects.values_list("server_name", flat=True).distinct())
        level_names = SortedDict((str(k), v) for k, v in LOG_LEVELS)

        logger = request.GET.get("logger")
        server_name = request.GET.get("server_name") or ""
        level = request.GET.get("level") or ""

        realtime = not (request.GET.get("p") > 1)

        if logger not in logger_names:
            logger = ""

        if server_name not in server_names:
            server_name = ""

        if level not in level_names:
            level = ""

        message_list = (
            GroupedMessage.objects.filter(status=0)
            .extra(
                select={
                    "score": "times_seen / (pow((floor(extract(epoch from now() - last_seen) / 3600) + 2), 1.25) + 1)"
                }
            )
            .order_by("-score", "-last_seen")
        )

        if logger:
            message_list = message_list.filter(logger=logger)

        if level:
            message_list = message_list.filter(level=level)

        if server_name:
            message_list = message_list.filter(message_set__server_name=server_name).distinct()

        data = [
            (
                m.pk,
                {
                    "html": render_to_string("sentry/partial/_group.html", {"group": m, "priority": p}),
                    "count": m.times_seen,
                    "priority": p,
                },
            )
            for m, p in with_priority(message_list[0:15])
        ]

    elif op == "resolve":
        gid = request.POST.get("gid")
        if not gid:
            return HttpResponseForbidden()
        GroupedMessage.objects.filter(pk=gid).update(status=1)
        data = {gid: 1}

    response = HttpResponse(simplejson.dumps(data))
    response["Content-Type"] = "application/json"
    return response
Пример #8
0
def ajax_handler(request):
    op = request.REQUEST.get('op')

    if op == 'poll':
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.extra(
            select={
                'score': GroupedMessage.get_score_clause(),
            })

        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        else:
            sort = 'priority'
            message_list = message_list.order_by('-score', '-last_seen')

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [(m.pk, {
            'html':
            render_to_string('sentry/partial/_group.html', {
                'group': m,
                'priority': p
            }),
            'count':
            m.times_seen,
            'priority':
            p,
        }) for m, p in with_priority(message_list[0:15])]

    elif op == 'resolve':
        gid = request.REQUEST.get('gid')
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(request.META['HTTP_REFERER'])

        data = [(m.pk, {
            'html':
            render_to_string('sentry/partial/_group.html', {'group': m}),
            'count':
            m.times_seen,
        }) for m in [group]]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(simplejson.dumps(data))
    response['Content-Type'] = 'application/json'
    return response
Пример #9
0
def ajax_handler(request):
    op = request.REQUEST.get('op')

    if op == 'notification':
        return render_to_response('sentry/partial/_notification.html', request.GET)
    elif op == 'poll':
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))


        message_list = GroupedMessage.objects.all()
        
        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        elif sort == 'freq':
            message_list = message_list.order_by('-times_seen')
        else:
            sort = 'priority'
            message_list = message_list.order_by('-score', '-last_seen')
        
        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)
        
        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'priority': p,
                    'request': request,
                }).strip(),
                'title': m.view or m.message_top(),
                'message': m.error(),
                'level': m.get_level_display(),
                'logger': m.logger,
                'count': m.times_seen,
                'priority': p,
            }) for m, p in with_priority(message_list[0:15])]

    elif op == 'resolve':
        gid = request.REQUEST.get('gid')
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()
        
        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1
        
        if not request.is_ajax():
            return HttpResponseRedirect(request.META.get('HTTP_REFERER') or reverse('sentry'))
        
        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'request': request,
                }).strip(),
                'count': m.times_seen,
            }) for m in [group]]
    else:
        return HttpResponseBadRequest()
        
    response = HttpResponse(simplejson.dumps(data))
    response['Content-Type'] = 'application/json'
    return response
Пример #10
0
def ajax_handler(request):
    op = request.REQUEST.get("op")

    if op == "notification":
        return render_to_response("sentry/partial/_notification.html", request.GET)
    elif op == "poll":
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.all()

        sort = request.GET.get("sort")
        if sort == "date":
            message_list = message_list.order_by("-last_seen")
        elif sort == "new":
            message_list = message_list.order_by("-first_seen")
        elif sort == "freq":
            message_list = message_list.order_by("-times_seen")
        else:
            sort = "priority"
            message_list = message_list.order_by("-score", "-last_seen")

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [
            (
                m.pk,
                {
                    "html": render_to_string(
                        "sentry/partial/_group.html", {"group": m, "priority": p, "request": request}
                    ).strip(),
                    "title": m.view or m.message_top(),
                    "message": m.error(),
                    "level": m.get_level_display(),
                    "logger": m.logger,
                    "count": m.times_seen,
                    "priority": p,
                },
            )
            for m, p in with_priority(message_list[0:15])
        ]

    elif op == "resolve":
        gid = request.REQUEST.get("gid")
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(request.META.get("HTTP_REFERER") or reverse("sentry"))

        data = [
            (
                m.pk,
                {
                    "html": render_to_string("sentry/partial/_group.html", {"group": m, "request": request}).strip(),
                    "count": m.times_seen,
                },
            )
            for m in [group]
        ]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(json.dumps(data))
    response["Content-Type"] = "application/json"
    return response
Пример #11
0
def ajax_handler(request):
    op = request.REQUEST.get('op')

    if op == 'notification':
        return render_to_response('sentry/partial/_notification.html', request.GET)
    elif op == 'poll':
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        query = request.GET.get('content')
        is_search = query

        if is_search:
            message_list = get_search_query_set(query)
        else:
            message_list = GroupedMessage.objects.extra(
                select={
                    'score': GroupedMessage.get_score_clause(),
                }
            )
            if query:
                # You really shouldnt be doing this
                message_list = message_list.filter(
                    Q(view__icontains=query) \
                    | Q(message__icontains=query) \
                    | Q(traceback__icontains=query)
                )

        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        else:
            sort = 'priority'
            if not is_search:
                message_list = message_list.order_by('-score', '-last_seen')

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'priority': p,
                    'request': request,
                }).strip(),
                'title': m.view or m.message_top(),
                'message': m.error(),
                'level': m.get_level_display(),
                'logger': m.logger,
                'count': m.times_seen,
                'priority': p,
            }) for m, p in with_priority(message_list[0:15])]

    elif op == 'resolve':
        gid = request.REQUEST.get('gid')
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(request.META['HTTP_REFERER'])

        data = [
            (m.pk, {
                'html': render_to_string('sentry/partial/_group.html', {
                    'group': m,
                    'request': request,
                }).strip(),
                'count': m.times_seen,
            }) for m in [group]]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(json.dumps(data))
    response['Content-Type'] = 'application/json'
    return response
Пример #12
0
def ajax_handler(request):
    op = request.REQUEST.get("op")

    if op == "notification":
        return render_to_response("sentry/partial/_notification.html", request.GET)
    elif op == "poll":
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        query = request.GET.get("content")
        is_search = query

        if is_search:
            message_list = get_search_query_set(query)
        else:
            message_list = GroupedMessage.objects.extra(select={"score": GroupedMessage.get_score_clause()})
            if query:
                # You really shouldnt be doing this
                message_list = message_list.filter(
                    Q(view__icontains=query) | Q(message__icontains=query) | Q(traceback__icontains=query)
                )

        sort = request.GET.get("sort")
        if sort == "date":
            message_list = message_list.order_by("-last_seen")
        elif sort == "new":
            message_list = message_list.order_by("-first_seen")
        else:
            sort = "priority"
            if not is_search:
                message_list = message_list.order_by("-score", "-last_seen")

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [
            (
                m.pk,
                {
                    "html": render_to_string(
                        "sentry/partial/_group.html", {"group": m, "priority": p, "request": request}
                    ).strip(),
                    "title": m.view or m.message_top(),
                    "message": m.error(),
                    "level": m.get_level_display(),
                    "logger": m.logger,
                    "count": m.times_seen,
                    "priority": p,
                },
            )
            for m, p in with_priority(message_list[0:15])
        ]

    elif op == "resolve":
        gid = request.REQUEST.get("gid")
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(request.META["HTTP_REFERER"])

        data = [
            (
                m.pk,
                {
                    "html": render_to_string("sentry/partial/_group.html", {"group": m, "request": request}).strip(),
                    "count": m.times_seen,
                },
            )
            for m in [group]
        ]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(simplejson.dumps(data))
    response["Content-Type"] = "application/json"
    return response
Пример #13
0
def ajax_handler(request):
    op = request.REQUEST.get('op')

    if op == 'notification':
        return render_to_response('sentry/partial/_notification.html',
                                  request.GET)
    elif op == 'poll':
        filters = []
        for filter_ in get_filters():
            filters.append(filter_(request))

        message_list = GroupedMessage.objects.all()

        sort = request.GET.get('sort')
        if sort == 'date':
            message_list = message_list.order_by('-last_seen')
        elif sort == 'new':
            message_list = message_list.order_by('-first_seen')
        elif sort == 'freq':
            message_list = message_list.order_by('-times_seen')
        else:
            sort = 'priority'
            message_list = message_list.order_by('-score', '-last_seen')

        for filter_ in filters:
            if not filter_.is_set():
                continue
            message_list = filter_.get_query_set(message_list)

        data = [(m.pk, {
            'html':
            render_to_string('sentry/partial/_group.html', {
                'group': m,
                'priority': p,
                'request': request,
            }).strip(),
            'title':
            m.view or m.message_top(),
            'message':
            m.error(),
            'level':
            m.get_level_display(),
            'logger':
            m.logger,
            'count':
            m.times_seen,
            'priority':
            p,
        }) for m, p in with_priority(message_list[0:15])]

    elif op == 'resolve':
        gid = request.REQUEST.get('gid')
        if not gid:
            return HttpResponseForbidden()
        try:
            group = GroupedMessage.objects.get(pk=gid)
        except GroupedMessage.DoesNotExist:
            return HttpResponseForbidden()

        GroupedMessage.objects.filter(pk=group.pk).update(status=1)
        group.status = 1

        if not request.is_ajax():
            return HttpResponseRedirect(
                request.META.get('HTTP_REFERER') or reverse('sentry'))

        data = [(m.pk, {
            'html':
            render_to_string('sentry/partial/_group.html', {
                'group': m,
                'request': request,
            }).strip(),
            'count':
            m.times_seen,
        }) for m in [group]]
    else:
        return HttpResponseBadRequest()

    response = HttpResponse(simplejson.dumps(data))
    response['Content-Type'] = 'application/json'
    return response