Пример #1
0
def metrics(request, game_uuid):
    try:
        game = Game.objects.get(uuid=game_uuid)
    except Game.DoesNotExist:
        return api_error('Requested game does not exist', code=404)
    except Game.MultipleObjectsReturned:
        return api_error('Internal server error', code=500)

    try:
        container = fieldmarshal.loads(MetricContainer, request.body)
    except ValueError:
        return api_error('Could not parse JSON body', code=400)

    events = {}

    for metric in container.metrics:
        if metric.event not in events:
            events[metric.event] = []

        metric.properties['game_uuid'] = game.uuid
        events[metric.event].append(metric.properties)

    # Keen to the rescue
    keen.add_events(events)

    return jsonify('', code=204)
Пример #2
0
def errors(request, game_uuid):
    try:
        game = Game.objects.get(uuid=game_uuid)
    except Game.DoesNotExist:
        return api_error('Requested game does not exist', code=404)
    except Game.MultipleObjectsReturned:
        return api_error('Internal server error', code=500)

    try:
        container = fieldmarshal.loads(ReportContainer, request.body)
    except ValueError:
        return api_error('Could not parse JSON body', code=400)

    crashes = []

    for report in container.errors:
        data = fieldmarshal.dumpd(report.tags)
        data['game_uuid'] = game.uuid
        crashes.append(data)

    keen.add_events({
        'crashes': crashes,
    })

    for report in container.errors:
        c = CrashReport(game=game, traceback=report.message)
        c.distinct_id = report.tags.distinct_id
        c.os = report.tags.os
        c.version = report.tags.version
        c.save()

    return api_error('', code=204)
Пример #3
0
def handle_results(results, options):
    """
    results is a dict that maps from hostname to the # of open conns on that host
    """

    all_under_limit = True
    over_limit_hosts = []
    for (host, num_conns) in results.iteritems():
        if num_conns > options.maxconns:
            all_under_limit = False
            over_limit_hosts.append((host, num_conns))

    if not all_under_limit:
        # one of the hosts was over, alert
        text = "DRPC server's open connections over threshold on the following hosts:\n\n"
        over_limit_hosts = sorted(over_limit_hosts)
        for host in over_limit_hosts:
            text += "{}: {}\n".format(host, results[host])
        emailer.Emailer.send_email(addr_to=options.email, subject="DRPC Server Open Conns Too High",
                                   text=text, categories=["open_drpc_conn_mon"])

    events = []
    for (host, num_conns) in results.iteritems():
        events.append({
            "host": host,
            "numconns": num_conns,
            "maxconns": options.maxconns,
            "over_limit": host in over_limit_hosts
        })

    keen.add_events({"open_drpc_conn_mon": events})
Пример #4
0
 def test_module_level_add_events(self):
     keen.project_id = "5004ded1163d66114f000000"
     api_key = "2e79c6ec1d0145be8891bf668599c79a"
     keen.write_key = scoped_keys.encrypt(api_key,
                                          {"allowed_operations": ["write"]})
     # client = KeenClient(project_id, write_key=write_key, read_key=read_key)
     keen.add_events({"python_test": [{"hello": "goodbye"}]})
Пример #5
0
def mark_user_views_event(event_id, user_id, ip_address):
    if user_id:
        view = View()
        view.event_id = event_id
        view.user_id = user_id
        view.save()

    ipview, created = ViewIP.objects.get_or_create(event_id=event_id, ip_address=ip_address)
    ipview.count = F('count') + 1
    ipview.save()

    # Send info to keen
    staff_status = False
    if user_id:
        try:
            user = get_user_model().objects.get(pk=user_id)
            staff_status = user.is_staff
        except get_user_model().DoesNotExist:
            keen.add_event("Error", {
                "msg": "User.DoesNotExist",
                "id": user_id
            })

    event = Event.objects.get(pk=event_id)

    keen_events = []

    for category in event.category.all():
        keen_events.append({
            'keen': {
                'time_stamp': timezone.now().isoformat(),
                'location': {
                    'coordinates': [float(event.venue.longitude), float(event.venue.latitude)],
                }
            },
            "user": {
                "user_id": user_id,
                "staff": staff_status,
                "ip": ip_address
            },
            "event": {
                "event_id": event_id,
                "category": category.name,
                "min_age": event.min_age,
                "max_age": event.max_age,
                "cost": event.cost,
                "start_date": event.start_date.isoformat(),
                "end_date": event.end_date.isoformat() if event.end_date else None,
                "publish_date": event.published_at.isoformat() if event.published_at else None
            },
            "venue": {
                "venue_id": event.venue.id,
                "name": event.venue.name,
                "city": event.venue.city,
                "neighborhood": event.venue.neighborhood,
            }})

    keen.add_events({"view_single": keen_events})
Пример #6
0
 def get(self):
     current_time = datetime.datetime.utcnow()
     one_hour_ago = current_time - datetime.timedelta(hours=1)
     visits = [serialize_ndb_model(visit)
               for visit in Visit.query(Visit.timestamp >= one_hour_ago)]
     if visits:
         keen.add_events({
             'visits': visits,
         })
Пример #7
0
def keen_add_events(event_collection, payload):
    '''
    Wrapper for keen.add_events(), adds project info to each event
    Param event_collection : collection event data is submitted to
    Param payload : array of events that is submitted
    '''
    # add project info to each event
    payload = add_project_info_list(payload)

    # submit list of events to Keen.io
    keen.add_events({event_collection: payload})
Пример #8
0
def send_data_to_keen(keen_json):
    hey = ""
    contents = read_contents(keen_json)
    for key in contents.keys():
        print "XANDER LOOK HERE"
        hey = key
        events = contents.get(key)
        for event in events:
            keen.add_events({str(key): [event]})
            mynewkeys = event.keys()

    return hey, mynewkeys
Пример #9
0
def add_events(event_collection, payload):
    """
    Wrapper for keen.add_events(), adds project info to each event.

    Param event_collection : collection event data is submitted to
    Param payload : array of events that is submitted
    """
    # add project info to each event
    payload = add_project_info_list(payload)

    # submit list of events to Keen.io
    keen.add_events({event_collection: payload})
    logger.info(
        "Sent multiple events to '%s' collection (Keen.io)",
        event_collection
    )
Пример #10
0
    def test_direct_persistence_strategy(self, post):
        post.return_value = self.SINGLE_ADD_RESPONSE
        keen.add_event("python_test", {"hello": "goodbye"})
        keen.add_event("python_test", {"hello": "goodbye"})

        post.return_value = self.MULTI_ADD_RESPONSE
        keen.add_events(
            {
                "sign_ups": [{
                    "username": "******",
                    "referred_by": "steve",
                    "son_of": "my_mom"
                }],
                "purchases": [
                    {"price": 5},
                    {"price": 6},
                    {"price": 7}
                ]}
        )
Пример #11
0
    def test_direct_persistence_strategy(self, post):
        post.return_value = self.SINGLE_ADD_RESPONSE
        keen.add_event("python_test", {"hello": "goodbye"})
        keen.add_event("python_test", {"hello": "goodbye"})

        post.return_value = self.MULTI_ADD_RESPONSE
        keen.add_events(
            {
                "sign_ups": [{
                    "username": "******",
                    "referred_by": "steve",
                    "son_of": "my_mom"
                }],
                "purchases": [
                    {"price": 5},
                    {"price": 6},
                    {"price": 7}
                ]}
        )
Пример #12
0
def submit_order(request):
    json_request = json.loads(request.body)
    trades = json_request.get('trades')
    cash = json_request.get('cash')
    reasoning = json_request.get('reasoning')
    notes = json_request.get('notes')

    if trades is None or cash is None:
        return HttpResponseBadRequest('Error: missing trade information')

    group = get_group(request)
    if isinstance(group, HttpResponseForbidden):
        return group

    if DEBUG != 'True':
        keen.add_events({
            'trades':
            trades,
            'orders': [{
                'group': group.get('group_account'),
                'email': request.user.email
            }]
        })

    try:
        sender = '%s %s <%s>' % (request.user.first_name,
                                 request.user.last_name, request.user.email)
        other_members = group.get('members').exclude(email=request.user.email)
        other_members_emails = [
            '%s %s <%s>' % (member.first_name, member.last_name, member.email)
            for member in other_members
        ]

        supervisors = [
            '%s %s <%s>' %
            (supervisor.first_name, supervisor.last_name, supervisor.email)
            for supervisor in group.get('supervisors')
        ]

        trader_content = render_to_string(
            'trade/email_template.html', {
                'trades': trades,
                'cash': cash,
                'notes': notes,
                'group_account': group.get('group_account'),
                'group_number': group.get('group_number')
            }, request)

        supervisor_content = render_to_string(
            'trade/email_template.html', {
                'trades': trades,
                'cash': cash,
                'reasoning': reasoning,
                'notes': notes,
                'group_account': group.get('group_account'),
                'group_number': group.get('group_number')
            }, request)
        from aitrading.templatetags.template_tags import remove_extra_0
        trader_msg = EmailMessage(
            from_email=sender,
            to=supervisors,
            bcc=[sender],
            cc=other_members_emails,
            subject='Applied Investments Trade Request - Group %s (%s)' %
            (group.get('group_number'),
             remove_extra_0(group.get('group_account'))),
            body=str(trader_content))
        trader_msg.content_subtype = 'html'
        trader_msg.send()

        supervisor_msg = EmailMessage(
            from_email=sender,
            to=supervisors,
            bcc=[sender],
            cc=other_members_emails,
            subject=
            'Reasoning for Applied Investments Trade Request - Group %s (%s)' %
            (group.get('group_number'),
             remove_extra_0(group.get('group_account'))),
            body=str(supervisor_content))
        supervisor_msg.content_subtype = 'html'
        supervisor_msg.send()

        return JsonResponse(data={})

    except Exception as e:
        return HttpResponse('Error: ' + str(e), status=500)
Пример #13
0
 def test_module_level_add_events(self, post):
     post.return_value = self.MULTI_ADD_RESPONSE
     keen.add_events({"python_test": [{"hello": "goodbye"}]})
Пример #14
0
def _send_to_keen(survey_key, course_key, answer_keys):
    events = []
    student = Student.query(Student.user == survey_key.get().participant).get()
    course = course_key.get()
    answers = ndb.get_multi(answer_keys)
    for answer in answers:
        question = answer.question.get()
        if answer.string_value != '':
            response = urlfetch.fetch(
                'http://text-processing.com/api/sentiment',
                payload=urllib.urlencode({'text': answer.string_value}),
                method=urlfetch.POST)

            # If we've been throttled, just give up and die
            if response.status_code == 503:
                continue

            elif response.status_code != 200:
                raise deferred.PermanentTaskFailure()

            sentiment = json.loads(response.content)
            answer.sentiment = sentiment['label']
            answer.put()

        lecturer = course.lecturer.get()
        event = {
            'question_key': question.key.urlsafe(),
            'survey_key': answer.key.parent().urlsafe(),
            'course_key': course.key.urlsafe(),
            'course': {
                'name': course.course.get().name,
                'department': course.course.get().department.urlsafe(),
                'faculty': course.course.get().faculty.urlsafe(),
                'school': course.course.get().faculty.get().school.urlsafe(),
            },
            'question_number': question.number,
            'question_text': question.question,
            'lecturer': {
                'key': lecturer.key.urlsafe(),
                'name': lecturer.name,
                'department': lecturer.department.get().name,
                'faculty': lecturer.department.get().faculty.get().name,
            },
            'student': {
                'key': student.key.urlsafe(),
                'age': student.calculate_age(),
                'gender': student.gender,
                'status': student.status,
                'year': student.year,
            },
        }

        if question.question_type == 'closed':
            event['response'] = answer.int_value

        else:
            event['sentiment'] = answer.sentiment

        events.append(event)

    keen.add_events({'answers': events})
Пример #15
0
 def test_module_level_add_events(self, post):
     post.return_value = self.MULTI_ADD_RESPONSE
     keen.add_events({"python_test": [{"hello": "goodbye"}]})
Пример #16
0
def sendStats (stats):
	log(">>> send stats")
	keen.add_events(stats)
	log("<<< send stats")
 def test_module_level_add_events(self):
     keen.project_id = "5004ded1163d66114f000000"
     api_key = "2e79c6ec1d0145be8891bf668599c79a"
     keen.write_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]})
     # client = KeenClient(project_id, write_key=write_key, read_key=read_key)
     keen.add_events({"python_test": [{"hello": "goodbye"}]})
Пример #18
0
def mark_user_views_event(event_id, user_id, ip_address):
    if user_id:
        view = View()
        view.event_id = event_id
        view.user_id = user_id
        view.save()

    ipview, created = ViewIP.objects.get_or_create(event_id=event_id,
                                                   ip_address=ip_address)
    ipview.count = F('count') + 1
    ipview.save()

    # Send info to keen
    staff_status = False
    if user_id:
        try:
            user = get_user_model().objects.get(pk=user_id)
            staff_status = user.is_staff
        except get_user_model().DoesNotExist:
            keen.add_event("Error", {
                "msg": "User.DoesNotExist",
                "id": user_id
            })

    event = Event.objects.get(pk=event_id)

    keen_events = []

    for category in event.category.all():
        keen_events.append({
            'keen': {
                'time_stamp': timezone.now().isoformat(),
                'location': {
                    'coordinates': [
                        float(event.venue.longitude),
                        float(event.venue.latitude)
                    ],
                }
            },
            "user": {
                "user_id": user_id,
                "staff": staff_status,
                "ip": ip_address
            },
            "event": {
                "event_id":
                event_id,
                "category":
                category.name,
                "min_age":
                event.min_age,
                "max_age":
                event.max_age,
                "cost":
                event.cost,
                "start_date":
                event.start_date.isoformat(),
                "end_date":
                event.end_date.isoformat() if event.end_date else None,
                "publish_date":
                event.published_at.isoformat() if event.published_at else None
            },
            "venue": {
                "venue_id": event.venue.id,
                "name": event.venue.name,
                "city": event.venue.city,
                "neighborhood": event.venue.neighborhood,
            }
        })

    keen.add_events({"view_single": keen_events})