Example #1
0
 def get_sample(self, meter_name, query ):
     samples = ceilometer.sample_list(self.request, meter_name, query=query)
     resources = []
     sample_data = []
     i = 0
     for s in samples:
         if s.resource_id not in resources:
             resources.append(s.resource_id)
             s.id = i
             sample_data.append(s)
         i += 1
     return sample_data
Example #2
0
    def _get_previous_val(self, source, resource, limit_date):
        date_object = datetime.strptime(limit_date, '%Y-%m-%d %H:%M:%S')
        edge_date = date_object - timedelta(hours=1)
        edge_date_str = edge_date.strftime('%Y-%m-%d %H:%M:%S')

        query = [
            {'field':'timestamp', 'op':'ge', 'value':edge_date_str},
            {'field':'timestamp', 'op':'lt', 'value':limit_date},
            {'field':'resource', 'op':'eq', 'value':resource}
        ]
        sample_list = ceilometer.sample_list(self.request, source, query)
        if len(sample_list)>0:
            last = sample_list[-1]
            return last.counter_volume
        else:
            return 0
Example #3
0
    def get(self, request, *args, **kwargs):
        source = request.GET.get('sample', '')
        date_from = request.GET.get('from', '')
        date_to = request.GET.get('to', '')
        resource = request.GET.get('resource', '')
        query = []
        rows = []

        if date_from:
            date_from = self._to_iso_time(date_from+' 00:00:00')
            query.append({'field':'timestamp', 'op':'ge', 'value':date_from})

        if date_to:
            date_to = self._to_iso_time(date_to+" 23:59:59")
            query.append({'field':'timestamp', 'op':'le', 'value':date_to})

        samples = []
        meter_type = ""
        if source and resource:
            query.append({'field':'resource', 'op':'eq', 'value':resource})
            sample_list = ceilometer.sample_list(self.request, source, query)

            previous = self._get_previous_val(source, resource, date_from)

            for sample_data in sample_list:
                current_volume = sample_data.counter_volume

                # if sample is cumulative, substract previous val
                meter_type = sample_data.counter_type
                if sample_data.counter_type=="cumulative":
                    current_delta = current_volume - previous
                    previous = current_volume
                    if current_delta<0:
                        current_delta = current_volume
                else:
                    current_delta = current_volume
                samples.append([sample_data.timestamp[:19], current_delta])

            # if requested period is too long, interpolate data, for cumulative metrics
            if meter_type=="cumulative":
                date_start_obj = datetime.strptime(date_from, "%Y-%m-%d %H:%M:%S")
                date_end_obj = datetime.strptime(date_to, "%Y-%m-%d %H:%M:%S")
                delta = (date_end_obj - date_start_obj).days

                if delta>=365:
                    samples = map(to_days, samples)
                    samples = reduce_metrics(samples)
                elif delta>=30:
                    # reduce metrics to hours
                    samples = map(to_hours, samples)
                    samples = reduce_metrics(samples)
            else:
                # add measures of 0 for start and end 
                samples.append([date_from.replace(" ", "T"), 0])
                samples.append([date_to.replace(" ", "T"), 0])

        # output csv
        headers = ['date', 'value']
        response = HttpResponse(mimetype='text/csv')
        writer = csv.writer(response)
        writer.writerow(headers)

        for sample in samples:
            writer.writerow(sample)

        return response
Example #4
0
def query_data_by_sample(request,
                         date_from,
                         date_to,
                         date_options,
                         group_by,
                         meter,
                         limit,
                         uuid,
                         period=None,
                         additional_query=None):
    date_from, date_to = _calc_date_args(date_from, date_to, date_options)
    unit = ""
    if not period:
        period = _calc_period(date_from, date_to)
    if additional_query is None:
        additional_query = []
    if date_from:
        additional_query += [{
            'field': 'timestamp',
            'op': 'ge',
            'value': date_from
        }]
    if date_to:
        additional_query += [{
            'field': 'timestamp',
            'op': 'le',
            'value': date_to
        }]
    additional_query += [{'field': 'resource_id', 'op': 'like', 'value': uuid}]

    # TODO(lsmola) replace this by logic implemented in I1 in bugs
    # 1226479 and 1226482, this is just a quick fix for RC1

    if group_by == "project":
        try:
            tenants, more = api.keystone.tenant_list(request,
                                                     domain=None,
                                                     paginate=False)
        except Exception:
            tenants = []
            exceptions.handle(request, _('Unable to retrieve project list.'))
        queries = {}
        for tenant in tenants:
            tenant_query = [{
                "field": "project_id",
                "op": "eq",
                "value": tenant.id
            }]

            queries[tenant.name] = tenant_query

        ceilometer_usage = ceilometer.CeilometerUsage(request)
        resources = ceilometer_usage.resource_aggregates_with_statistics(
            queries, [meter],
            period=period,
            stats_attr=None,
            additional_query=additional_query)

    else:
        query = additional_query

        def filter_by_meter_name(resource):
            """Function for filtering of the list of resources.

            Will pick the right resources according to currently selected
            meter.
            """
            for link in resource.links:
                if link['rel'] == meter:
                    # If resource has the currently chosen meter.
                    return True
            return False

        try:
            ceilometer_usage = ceilometer.sample_list(request,
                                                      meter,
                                                      query,
                                                      limits=limit)

            if not ceilometer_usage:
                unit = ""
            else:
                unit = ceilometer_usage[0].counter_unit

            # resources = ceilometer_usage.resources_with_statistics(
            #     query, [meter], period=period, stats_attr=None,
            #     additional_query=additional_query,
            #     filter_func=filter_by_meter_name)
        except Exception:
            resources = []
            unit = ""
            exceptions.handle(request, _('Unable to retrieve statistics.'))
    return ceilometer_usage, unit