Some Custom Group Dimensions may have fairly simple and straight forward logic which defines them. For those cases, a set of short form rules can be used that provide a simpler ways to define a Custom Group Dimension. Short form rules are useful when you have simple cases where you do not need to combine rule types (i.e. Group and GroupBy rules).

Custom Group Dimensions defined using a short form rule use the same properties as any other Custom Group Dimension definition. However, instead of a Rules section, you use one of the two short form rules: Groups and GroupBy.

Additionally, Custom Allocation Dimensions are always defined using short form rules.

Groups Short Form Rule

The Groups short form rule allows you to easily define static element names with conditions for which charges go into the elements. All conditions are supported, including conditions with source overrides.

A Groups short form rule is defined as follows:

  <DimensionId>:
    <Base Dimension Properties>
    Groups:
      <Element Name 1>:
        - <Conditions>
      <Element Name 2>:
        - <Conditions>
      <Element Name N>:
        - <Conditions>

For example, consider a case where you have a simple mapping for environments where most charges can be determined by account IDs with a few exceptions. To do this with the Group rule, the definition would be:

  Environment:
    Source: Account
    Rules:
      - Type: Group
         Name: Production
         Conditions:
           - Equals:
              - 123456789010
              - 123456789011
      - Type: Group
         Name: DevOps
         Conditions:
           - Equals:
              - 123456789012
              - 123456789013
           - Source: CZ:Defined:Category
             Equals: Cloud Management
           - Source: Service
             Contains: Support
      - Type: Group
         Name: Development
         Conditions:
           - Equals:
              - 123456789014
              - 123456789015
      - Type: Group
         Name: Test
         Conditions:
           - Equals:
              - 123456789016
              - 123456789017

Using the short from Groups rule, this can be simplified into:

  Environment:
    Source: Account
    Groups:
      Production:
         - Equals:
            - 123456789010
            - 123456789011
      DevOps:
         - Equals:
            - 123456789012
            - 123456789013
         - Source: CZ:Defined:Category
           Equals: Cloud Management
         - Source: Service
           Contains: Support
      Development:
         - Equals:
            - 123456789014
            - 123456789015
      Test:
         - Equals:
            - 123456789016
            - 123456789017

GroupBy Short Form Rule

The GroupBy short form rule is useful when you are only grouping elements by a single set of sources, with or without transforms.

The GroupBy short form rule is defined as follows:

  <DimensionId>:
    <Base Dimension Properties>
    GroupBy:
      <Source Properties>
      Format: <Format string>
      Conditions:
         - <Conditions>

The properties supported in the GroupBy section are the same as the GroupBy rule except for the Type property, which is not used in this form.

So for example, if you were going to create a dimension that divided your charges by country code, you would define it as follows:

  CountryCode:
    Name: Country Code
    DefaultValue: Global
    Rules:
      - Type: GroupBy
        Source: Region
        Transforms:
          - Type: Split
            Delimiter: '-'
            Index: 1

Using the short form rule, this would be:

  CountryCode:
    Name: Country Code
    DefaultValue: Global
    GroupBy:
      Source: Region
      Transforms:
        - Type: Split
          Delimiter: '-'
          Index: 1

AllocateByStreams Short Form Rule

This dimension can only be defined using the short form and allows splitting costs using telemetry. The syntax is as follows:

  <DimensionId>:
    <Base Dimension Properties>
    Type: Allocation
    AllocateByStreams:
      Streams:
        - <Stream>

AllocateByRules Short Form Rule

This dimension can only be defined using the short form and allows splitting costs among the elements of another dimension, either evenly or proportionally.

AllocateByRules supports four keys:

AllocationMethod: How to split the costs (Even or Proportional)
SpendToAllocate: What costs to split
AcrossElements: What elements the cost will be split across (and the proportions for each element's cost, if using proportional allocation)
Optional: ForEachElementOf: How to refine a proportional allocation by splitting the costs proportionally across another dimension

The AllocateByRules syntax is as follows:

  <DimensionId>:
    <Base Dimension Properties>
    Type: Allocation
    AllocateByRules:
      AllocationMethod: <...>
      SpendToAllocate: <...>
      AcrossElements: <...>
      ForEachElementOf: <...> # Optional; can only be used with proportional allocation

SpendToAllocate

The SpendToAllocate attribute defines what spend you want to split.

Supported SpendToAllocate keys:

Source
Sources
CoalesceSources
Conditions

For example, the following code defines an allocation dimension with the ID RDSSplitCosts that splits the cost of AWS RDS spend in the account 123456789012:

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod: <...>

      SpendToAllocate:
        Conditions:
          - And:
            - Source: Account
              Equals: 123456789012
            - Source: Service
              Equals: AWS RDS

AcrossElements

AcrossElements defines the elements in the custom allocation dimension. If you use the Proportional method, AcrossElements also defines the proportions for how the cost will be split.

Supported AcrossElements keys:

Source
Sources
Transforms

For example, the following code defines an allocation dimension where the RDS spend is split across 3 elements in the SingleTenantProduct dimension, which are Product A, Product B, and Product C:

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod: <...>
      SpendToAllocate:
        Conditions:
          - And:
            - Source: Account
              Equals: 123456789012
            - Source: Service
              Equals: AWS RDS

      AcrossElements:
        Rules:
          - Type: GroupBy
            Source: SingleTenantProduct
            Conditions:
              - Equals:
                - Product A
                - Product B
                - Product C

This code sample defines AcrossElements using Rules syntax, but you can also use the short form syntax for Groups or GroupBy.

Using GroupBy short form:

      AcrossElements:
        GroupBy:
          Source: SingleTenantProduct
          Conditions:
            - Equals:
                - Product A
                - Product B
                - Product C

Using Groups short form:

      AcrossElements:
        Source: SingleTenantProduct
        Groups:
          Product A:
            - Equals: Product A
          Product B:
            - Equals: Product B
          Product C:
            - Equals: Product C

AllocationMethod: Even

If AllocationMethod is Even, the cost of each element in the rules allocation dimension is the same. You can calculate it as:

the cost defined in SpendToAllocate,
divided by the number of distinct elements in AcrossElements.

Note that the Even allocation method uses the Real Cost of the targets.

For example, the following code defines an allocation dimension where the RDS spend is split evenly across 3 elements in the SingleTenantProduct dimension, which are Product A, Product B, and Product C:

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod: Even
      SpendToAllocate:
        Conditions:
          - And:
            - Source: Account
              Equals: 123456789012
            - Source: Service
              Equals: AWS RDS

      AcrossElements:
        Rules:
          - Type: GroupBy
            Source: SingleTenantProduct
            Conditions:
              - Equals:
                - Product A
                - Product B
                - Product C

AllocationMethod: Proportional

If AllocationMethod is Proportional, the cost of each element in the rules allocation dimension is defined relative to cost of the other elements in the dimension. You can calculate each element's cost as:

the cost defined in SpendToAllocate,
multiplied by the ratio of that element's cost vs. the sum of all elements in the inline dimension.

For example, let's say the dimension SingleTenantProduct has three elements, Product A, Product B, and Product C. Suppose that the total cost of all the elements in the SingleTenantProduct dimension is $1200, split using the following ratios:

Product A: 25% of $1200 = $300
Product B: 25% of $1200 = $300
Product C: 50% of $1200 = $600

As a result, if the SpendToAllocate is $100, each element would be allocated as follows:

Product A: 25% of $100 = $25
Product B: 25% of $100 = $25
Product C: 50% of $100 = $50

The following code defines an allocation dimension where the RDS spend is split proportionally across the 3 elements in the SingleTenantProduct dimension:

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod: Proportional
      SpendToAllocate:
        Conditions:
          - And:
            - Source: Account
              Equals: 123456789012
            - Source: Service
              Equals: AWS RDS

      AcrossElements:
        Rules:
          - Type: GroupBy
            Source: SingleTenantProduct
            Conditions:
              - Equals:
                - Product A
                - Product B
                - Product C

Proportional Allocation Cost Type and Granularity

When you use the Proportional method of allocation, you can specify the cost type and level of granularity.

The default cost type is RealCost and the default level of granularity is UsageDaily, but you can choose to use other supported values.

Supported cost types:

BilledCost
DiscountedCost
DiscountedAmortizedCost
AmortizedCost
InvoicedAmortizedCost
RealCost (default)
OnDemandCost
UsageAmount: A cost type available in Analytics

Supported granularity values:

UsageDaily (default)
UsageMonthly
BillingPeriod

To specify a non-default cost type or level of granularity, format the CostFormation as follows:

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod:
        Method: Proportional
        Granularity: <Level of granularity>
        CostType: <Cost type>

Note that this syntax adds a new key, Method.

For example, the following code defines an allocation dimension where the RDS spend is split proportionally across dimension elements, using ratios calculated based on monthly usage and Discounted Cost:

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod:
        Method: Proportional
        Granularity: UsageMonthly
        CostType: DiscountedCost

Using ForEachElementOf in Proportional Allocation

ForEachElementOf is an optional attribute that further categorizes SpendToAllocate based on another dimension. This is useful when you need to make a proportional allocation more nuanced, without having to create redundant filters or dimensions.

Supported ForEachElementOf keys:

Source
Sources
Transforms

For example, the following code defines an allocation dimension where the RDS spend is split proportionally across 3 elements in the SingleTenantProduct dimension, each of which is further divided proportionally across the types of Environment (either dev or prod):

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod: Proportional
      SpendToAllocate:
        Conditions:
          - And:
            - Source: Account
              Equals: 061190967865
            - Source: Service
              Equals: AWS RDS
      AcrossElements:
        GroupBy:
          Source: SingleTenantProduct
          Conditions:
            - Equals:
                - Product A
                - Product B
                - Product C

      ForEachElementOf:
        Source: Environment
        Values:
          - dev
          - prod

As a result of the preceding code, your RDS spend is allocated by product, and then by environment.

You can also write ForEachElementOf with the short form syntax for Groups or GroupBy (shown below):

  RDSSplitCosts:
    Name: RDS Split Costs
    Hide: True
    Type: Allocation
    AllocateByRules:
      AllocationMethod: Proportional
      SpendToAllocate:
        Conditions:
          - And:
            - Source: Account
              Equals: 061190967865
            - Source: Service
              Equals: AWS RDS
      AcrossElements:
        GroupBy:
          Source: SingleTenantProduct
          Conditions:
            - Equals:
                - Product A
                - Product B
                - Product C

      ForEachElementOf:
        GroupBy:
          Source: Region