Billing calculation of rates

Question

Azure Rate Card API returns a MeterRates field (see documentation). Azure UsageAggregate gives a quantity (see documentation).

According to the azure support page. This is the forum to ask questions.

So, how are meter rates applied?

Example meter rates:

{"0":20, "100":15, "200":10}

If I have a quantity of 175 is the amount 100*20 + 75*15 or 175*15?

Why specify an included quantity?

Example: rates:{"0":23} with included quantitiy 10 could be expressed as rates:

{"0":0, "10":23}

Answer 1

example meter rates: {"0":20, "100":15, "200":10}

if I have a quantity of 175 is the amount 100*20 + 75*15 or 175*15 ?

The pricing is tiered pricing. So when you get the rates it essentially tells you that:

• from 0 - 99 units, the unit rate is 20
• from 100 - 199 units, the unit rate is 15
• from 200 units and above, the unit rate is 10

Based on this logic, your calculation should be:

99 * 20 + 75 * 15 = 3105

One thing which confuses me though is the upper limit. Above calculation is based on the information I received from Azure Billing team. What confused me is what would happen if the consumption is say 99.5 units? For the first 99 units it is fine but I am not sure how the additional 0.5 units will be calculated.

Answer 2

Guarav gets at the core of the issue and is why I marked it as the answer. Based on that I devised the following code to implement the logic. It falls in two parts:

1. Creating a bucket list from the meter rates
2. Processing a quantity with the bucket list to determine an amount

The following function creates a list of buckets (each bucket object is a simple POCO with Min, Max and Rate properties). The list is attached to a meter object that has the other properties from the rate card api.

        private Dictionary<int, RateBucket> ParseRateBuckets(string rates)
    {
        dynamic dRates = JsonConvert.DeserializeObject(rates);
        var rateContainer = (JContainer)dRates;

        var buckets = new Dictionary<int, RateBucket>();
        var bucketNumber = 0;
        foreach (var jToken in rateContainer.Children())
        {
            var jProperty = jToken as JProperty;
            if (jProperty != null)
            {
                var bucket = new RateBucket
                {
                    Min = Convert.ToDouble(jProperty.Name),
                    Rate = Convert.ToDouble(jProperty.Value.ToString())
                };

                if (bucketNumber > 0)
                    buckets[bucketNumber - 1].Max = bucket.Min;

                buckets.Add(bucketNumber, bucket);
            }

            bucketNumber++;
        }

        return buckets;
    }

The second function uses the meter object with two useful properties: the bucket list, and the included quantity. According to the rate card documentation (as I read it) you don't start counting billable quantity until after you surpass the included quantity. I'm sure there's some refactoring that could be done here, but the ordered processing of the buckets is the key point.

I think I've addressed issue on the quantity by recognizing that it's a double and not an integer. Therefore the quantity associated with any single bucket is the difference between the bucket max and the bucket min (unless we've only filled a partial bucket).

        private double CalculateUsageCost(RateCardMeter meter, double quantity)
    {
        var amount = 0.0;

        quantity -= meter.IncludedQuantity;

        if (quantity > 0)
        {
            for (var i = 0; i < meter.RateBuckets.Count; i++)
            {
                var bucket = meter.RateBuckets[i];
                if (quantity > bucket.Min)
                {
                    if (bucket.Max.HasValue && quantity > bucket.Max)
                        amount += (bucket.Max.Value - bucket.Min)*bucket.Rate;
                    else
                        amount += (quantity - bucket.Min)*bucket.Rate;
                }
            }
        }
        return amount;
    }

Finally, the documentation is unclear about the time scope for the tiers. If I get a discounted price based on quantity, over what time scope do I aggregate quantity? The usage api allows me to pull data either daily or hourly. I want to pull my data hourly so I can correlate my costs by time of day. But when is it appropriate to actually calculate the bill? Seems like hourly is wrong, daily may work, but it might only be appropriate over the entire month.

Answer 3

Recently I just did this similar task. Following is my example (I think you can use regex to remove those characters rather than like me using replace). The first function parse the rate info string to generate a key-value pair collection, and the second function is used to calculate the total price.

private Dictionary<float, double> GetRatesDetail(string r)
{
    Dictionary<float, double> pairs = null;
    if(string.IsNullOrEmpty(r) || r.Length <=2)
    {
        pairs = new Dictionary<float, double>();
        pairs.Add(0, 0);
    }
    else
    {
        pairs = r.Replace("{", "").Replace("}", "").Split(',')
        .Select(value => value.Split(':'))
        .ToDictionary(pair => float.Parse(pair[0].Replace("\"", "")), pair => double.Parse(pair[1]));
    }

    return pairs;
}

public decimal Process(Dictionary<float, double> rates, decimal quantity)
{
    double ret = 0;

    foreach (int key in rates.Keys.OrderByDescending(k => k))
    {
        if (quantity >= key)
        {
            ret += ((double)quantity - key) * rates[key];
            quantity = key;
        }
    }

    return (decimal)ret;
}