def generator(params, timezone_offset): startTime,endTime = reportHelpers.calc_timeframe(params['timeframe']) # Get the "QUERY TIMED OUT" event type. We'll need this for our various # database queries. try: query_timed_out_event = EventType.objects.get(type="QUERY_TIMED_OUT") except EventType.DoesNotExist: query_timed_out_event = None # Now scan through the desired time period, grabbing all the # "QUERY TIMED OUT" events. results = [] # List of (timestamp, sql) tuples. if query_timed_out_event != None: for event in Event.objects.filter(timestamp__gte=startTime, timestamp__lte=endTime, type=query_timed_out_event): timestamp = reportHelpers.datetime_to_seconds(event.timestamp) # timezone_offset) results.append((timestamp, event.text)) # Finally, return the list of timed-out queries back to the caller. return (True, results)
def generator(params, timezone_offset): # Process our parameters. startTime,endTime = reportHelpers.calc_timeframe(params['timeframe']) if params['chunk_size'] == "m": chunk_size = datetime.timedelta(minutes=1) elif params['chunk_size'] == "h": chunk_size = datetime.timedelta(hours=1) elif params['chunk_size'] == "d": chunk_size = datetime.timedelta(days=1) else: return (False, "Unknown chunk_size value: " + repr(params['chunk_size'])) if params['date_choice'] == "source": date_field = "timestamp" elif params['date_choice'] == "3taps": date_field = "inserted" else: return (False, "Unknown date_choice value: " + repr(params['date_choice'])) # Build a list of the time periods within the desired timeframe. periods = [] period_start = startTime while period_start <= endTime: periods.append({'start' : period_start, 'end' : period_start + chunk_size - datetime.timedelta(microseconds=1)}) period_start = period_start + chunk_size # Calculate the total for each time period in turn. for period in periods: query = {date_field + "__gte" : period['start'], date_field + "__lte" : period['end']} period['num_postings'] = Posting.objects.filter(**query).count() # Assemble the results to display. results = [] # List of (period_start, num_postings) tuples. for period in periods: timestamp = reportHelpers.datetime_to_seconds(period['start'], timezone_offset) results.append((timestamp, period['num_postings'])) # Finally, return the results back to the caller. return (True, results)
def generator(params, timezone_offset): startTime,endTime = reportHelpers.calc_timeframe(params['timeframe']) # Get the "SUMMARY_REQUESTS" event type. We'll need this for our various # database queries. try: summary_requests_event = EventType.objects.get(type="SUMMARY_REQUESTS") except EventType.DoesNotExist: summary_requests_event = None # Now scan through the desired time period, grabbing all the # "SUMMARY_REQUESTS" events and passing them through a data reducer to keep # the number of data points reasonable. reducer = reportHelpers.DataReducer() reducer.set_max_num_data_points(1000) reducer.set_period(startTime, endTime) reducer.set_value_combiner(max) if summary_requests_event != None: for event in Event.objects.filter(timestamp__gte=startTime, timestamp__lte=endTime, type=summary_requests_event): num_requests = event.primary_value tot_time = event.secondary_value # milliseconds. time_per_request = tot_time / num_requests reducer.add(event.timestamp, time_per_request) reduced_data = reducer.get_reduced_data() # Finally, collate the results and return them back to the caller. results = {'startTime' : reportHelpers.datetime_to_seconds(startTime, timezone_offset), 'endTime' : reportHelpers.datetime_to_seconds(endTime, timezone_offset), 'periods' : [] # List of (timestamp, time_per_request) values. } if summary_requests_event != None: for period_start,period_end,max_time_per_request in reduced_data: timestamp = reportHelpers.datetime_to_seconds(period_start, timezone_offset) results['periods'].append((timestamp, max_time_per_request)) return (True, results)
def generator(params, timezone_offset): startTime,endTime = reportHelpers.calc_timeframe(params['timeframe']) # Get the "POSTINGS_QUEUED" and "POSTINGS_DEQUEUED" event types. We'll # need these for our various database queries. try: postings_queued_event = EventType.objects.get(type="POSTINGS_QUEUED") except EventType.DoesNotExist: postings_queued_event = None try: postings_dequeued_event = EventType.objects.get( type="POSTINGS_DEQUEUED") except EventType.DoesNotExist: postings_dequeued_event = None # Now calculate the queue size at the start of the time period. We get # this by summing up the total value of the POSTINGS_QUEUED events, and # then subtract the total value of the POSTINGS_DEQUEUED events, prior to # the starting time period. if postings_queued_event != None: query = Event.objects.filter(timestamp__lt=startTime, type=postings_queued_event) num_postings_added = \ query.aggregate(Sum("primary_value"))['primary_value__sum'] if num_postings_added == None: num_postings_added = 0 else: num_postings_added = 0 if postings_dequeued_event != None: query = Event.objects.filter(timestamp__lt=startTime, type=postings_dequeued_event) num_postings_removed = \ query.aggregate(Sum("primary_value"))['primary_value__sum'] if num_postings_removed == None: num_postings_removed = 0 else: num_postings_removed = 0 starting_queue_size = num_postings_added - num_postings_removed # Calculate the data to return to the caller. Note that we use a data # reducer to simplify the data as necessary. reducer = reportHelpers.DataReducer() reducer.set_max_num_data_points(1000) reducer.set_period(startTime, endTime) reducer.set_value_combiner(sum) if postings_queued_event != None: for event in Event.objects.filter(timestamp__gte=startTime, timestamp__lte=endTime, type=postings_queued_event): reducer.add(event.timestamp, event.primary_value) if postings_dequeued_event != None: for event in Event.objects.filter(timestamp__gte=startTime, timestamp__lte=endTime, type=postings_dequeued_event): reducer.add(event.timestamp, -event.primary_value) reduced_data = reducer.get_reduced_data() # We now have a (possibly reduced) list of the changes to the queue size # for the desired time period. Use these calculated values to build a # running total of the queue size over the time period. results = {'startTime' : reportHelpers.datetime_to_seconds(startTime, timezone_offset), 'endTime' : reportHelpers.datetime_to_seconds(endTime, timezone_offset), 'periods' : []} running_total = starting_queue_size for period_start,period_end,period_total in reduced_data: running_total = running_total + period_total timestamp = reportHelpers.datetime_to_seconds(period_start, timezone_offset) results['periods'].append((timestamp, running_total)) # Finally, return the calculated data back to the caller. return (True, results)