llm_cost_tracker 0.11.0 → 0.12.0

data/lib/llm_cost_tracker/providers/openai/service_charges.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "../../billing/line_item"
 require_relative "model_families"
 
 module LlmCostTracker
   module Providers
     module Openai
       module ServiceCharges
-        RESPONSE_OUTPUT_COMPONENTS = {
-          "web_search_call" => :web_search_request,
-          "file_search_call" => :file_search_call,
-          "code_interpreter_call" => :container_session,
-          "mcp_call" => :mcp_call
+        RESPONSE_OUTPUT_RENAMES = {
+          "web_search_call" => "web_search_request",
+          "code_interpreter_call" => "container_session"
         }.freeze
 
         module_function
@@ -53,7 +50,7 @@ module LlmCostTracker
         def chat_completions_used_web_search?(choices)
           Array(choices).any? do |choice|
             Array(choice.dig("message", "annotations")).any? do |annotation|
-              annotation.is_a?(Hash) && annotation["type"] == "url_citation"
+              annotation.is_a?(Hash) && annotation["type"].to_s == "url_citation"
             end
           end
         end
@@ -61,20 +58,22 @@ module LlmCostTracker
         def billable?(item)
           return false unless item.is_a?(Hash)
 
-          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
-          return false unless component
-          return true unless component == :web_search_request
+          dimension = output_dimension(item["type"])
+          return false unless dimension
+          return true unless dimension == "web_search_request"
 
           action_type = item.dig("action", "type")
           action_type.nil? || action_type == "search"
         end
 
         def store_output_item(output_items, item)
-          return unless item.is_a?(Hash) && RESPONSE_OUTPUT_COMPONENTS.key?(item["type"])
+          return unless item.is_a?(Hash)
 
-          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
-          key = if component == :container_session && item["container_id"]
-                  "#{component}:#{item['container_id']}"
+          dimension = output_dimension(item["type"])
+          return unless dimension
+
+          key = if dimension == "container_session" && item["container_id"]
+                  "#{dimension}:#{item['container_id']}"
                 else
                   item["id"] || "#{item['type']}:#{output_items.length}"
                 end
@@ -84,62 +83,68 @@ module LlmCostTracker
         def build_line_item(item, request: nil, model: nil)
           return nil unless item.is_a?(Hash)
 
-          component_key = component_key_for(item, request: request, model: model)
-          return nil unless component_key
+          dimension_key = dimension_key_for(item, request: request, model: model)
+          return nil unless dimension_key
 
-          provider_item_id = if component_key == :container_session
+          provider_item_id = if dimension_key == "container_session"
                                item["container_id"] || item["id"]
                              else
                                item["id"]
                              end
-          Billing::LineItem.build(
-            component_key: component_key,
+          Charges::LineItem.build(
+            dimension_key: dimension_key,
             quantity: 1,
-            cost_status: Billing::CostStatus::UNKNOWN,
-            pricing_basis: :provider_usage,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
             provider_field: item["provider_field"] || "response.output.#{item['type']}",
             provider_item_id: provider_item_id,
             details: line_item_details(item)
           )
         end
 
-        def component_key_for(item, request:, model:)
-          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
-          return component unless component == :web_search_request
-          return component unless web_search_preview_used?(request) || chat_completions_search_model?(model)
+        def dimension_key_for(item, request:, model:)
+          dimension = output_dimension(item["type"])
+          return dimension unless dimension == "web_search_request"
+          return dimension unless web_search_preview_used?(request) || chat_completions_search_model?(model)
+
+          reasoning_model?(model) ? "web_search_preview_request_reasoning" : "web_search_preview_request_non_reasoning"
+        end
 
-          reasoning_model?(model) ? :web_search_preview_request_reasoning : :web_search_preview_request_non_reasoning
+        def output_dimension(type)
+          key = RESPONSE_OUTPUT_RENAMES[type] || type
+          dimension = Usage::Catalog[key]
+          key if dimension && dimension.token_key.nil?
         end
 
         def web_search_preview_used?(request)
           tools = request && (request[:tools] || request["tools"])
-          return false unless tools.respond_to?(:each)
-
-          tools.any? do |tool|
+          Array(tools).any? do |tool|
             type = tool.is_a?(Hash) ? (tool[:type] || tool["type"]) : tool
             type.to_s.include?("web_search_preview")
           end
         end
 
         def chat_completions_search_model?(model)
-          return false unless model
-
-          name = model.to_s.split("/", 2).last
-          ModelFamilies.chat_completions_search?(name)
+          name = local_model_name(model)
+          name && ModelFamilies.chat_completions_search?(name)
         end
 
         def reasoning_model?(model)
-          return false unless model
+          name = local_model_name(model)
+          name && ModelFamilies.reasoning?(name)
+        end
 
-          name = model.to_s.split("/", 2).last
-          ModelFamilies.reasoning?(name)
+        def local_model_name(model)
+          return nil unless model
+
+          model.to_s.split("/", 2).last
         end
 
         def line_item_details(item)
           {
-            "status" => item["status"],
-            "action_type" => item.dig("action", "type"),
-            "container_id" => item["container_id"]
+            status: item["status"],
+            action_type: item.dig("action", "type"),
+            container_id: item["container_id"]
           }.compact
         end
 
@@ -151,6 +156,25 @@ module LlmCostTracker
           end
           line_items_from_output(output_items, request: request, model: model)
         end
+
+        def transcription_line_items(usage)
+          return [] unless usage
+
+          type = (usage[:type] || usage["type"]).to_s
+          return [] unless type == "duration"
+
+          seconds = (usage[:seconds] || usage["seconds"]).to_f
+          return [] unless seconds.positive?
+
+          [Charges::LineItem.build(
+            dimension_key: "transcription_minute",
+            quantity: (seconds / 60.0).ceil,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
+            provider_field: "usage.seconds",
+            details: { seconds: seconds }
+          )]
+        end
       end
     end
   end

data/lib/llm_cost_tracker/providers/openai/usage_extractor.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "model_families"
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module UsageExtractor
+        INPUT_DETAIL_KEYS = %i[input_tokens_details input_token_details prompt_tokens_details].freeze
+        OUTPUT_DETAIL_KEYS = %i[output_tokens_details output_token_details completion_tokens_details].freeze
+        def self.token_usage(usage, model: nil)
+          input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
+          output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
+          cache_read = cache_read_input_tokens(usage)
+          audio_input = audio_input_tokens(usage)
+          audio_output = audio_output_tokens(usage)
+          image_input = image_input_tokens(usage)
+          image_output, regular_output = split_output(
+            output_tokens: output_tokens,
+            image_output_details: image_output_tokens(usage),
+            text_output_details: text_output_tokens(usage),
+            audio_output: audio_output,
+            default_to_image: ModelFamilies.image_output?(model)
+          )
+
+          Usage::TokenUsage.build(
+            input_tokens: [input_tokens - cache_read - audio_input - image_input, 0].max,
+            output_tokens: regular_output,
+            total_tokens: usage[:total_tokens],
+            cache_read_input_tokens: cache_read,
+            audio_input_tokens: audio_input,
+            audio_output_tokens: audio_output,
+            image_input_tokens: image_input,
+            image_output_tokens: image_output,
+            hidden_output_tokens: hidden_output_tokens(usage)
+          )
+        end
+
+        def self.split_output(output_tokens:,
+                              image_output_details:,
+                              text_output_details:,
+                              audio_output:,
+                              default_to_image: false)
+          if image_output_details.zero? && text_output_details.zero?
+            remainder = [output_tokens - audio_output, 0].max
+            return default_to_image ? [remainder, 0] : [0, remainder]
+          end
+
+          text_output = text_output_details
+          text_output = [output_tokens - image_output_details - audio_output, 0].max if text_output.zero?
+          [image_output_details, text_output]
+        end
+
+        def self.cache_read_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens)
+        def self.hidden_output_tokens(usage)    = detail(usage, OUTPUT_DETAIL_KEYS, :reasoning_tokens)
+        def self.audio_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :audio_tokens)
+        def self.audio_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :audio_tokens)
+        def self.image_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :image_tokens)
+        def self.image_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :image_tokens)
+        def self.text_output_tokens(usage)      = detail(usage, OUTPUT_DETAIL_KEYS, :text_tokens)
+
+        def self.detail(usage, containers, key)
+          containers.each do |container|
+            value = usage.dig(container, key)
+            return value.to_i if value
+          end
+          0
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/openai_compatible/parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module OpenaiCompatible
+      class Parser < LlmCostTracker::Parsers::Base
+        include Openai::ResponseParser
+
+        TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
+
+        class << self
+          def match?(url)
+            match_uri?(url, path_suffixes: TRACKED_PATH_SUFFIXES) { |uri| provider_for_uri(uri) }
+          end
+
+          def provider_names
+            custom = LlmCostTracker.configuration.openai_compatible_providers.each_value.map do |provider|
+              provider.to_s.downcase
+            end
+            ["openai_compatible", *custom].uniq
+          end
+
+          def provider_for_uri(uri)
+            return nil unless uri
+
+            LlmCostTracker.configuration.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
+          end
+        end
+
+        def provider_for(request_url)
+          self.class.provider_for_uri(parsed_uri(request_url)) || "openai_compatible"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      autoload :Parser, "llm_cost_tracker/providers/anthropic/parser"
+      autoload :UsageExtractor, "llm_cost_tracker/providers/anthropic/usage_extractor"
+      autoload :ResponseParser, "llm_cost_tracker/providers/anthropic/response_parser"
+    end
+
+    module Azure
+      autoload :Hosts, "llm_cost_tracker/providers/azure/hosts"
+      autoload :Parser, "llm_cost_tracker/providers/azure/parser"
+    end
+
+    module Gemini
+      autoload :ModelFamilies, "llm_cost_tracker/providers/gemini/model_families"
+      autoload :Parser, "llm_cost_tracker/providers/gemini/parser"
+      autoload :UsageExtractor, "llm_cost_tracker/providers/gemini/usage_extractor"
+    end
+
+    module Openai
+      autoload :Hosts, "llm_cost_tracker/providers/openai/hosts"
+      autoload :ModelFamilies, "llm_cost_tracker/providers/openai/model_families"
+      autoload :Parser, "llm_cost_tracker/providers/openai/parser"
+      autoload :ServiceCharges, "llm_cost_tracker/providers/openai/service_charges"
+      autoload :UsageExtractor, "llm_cost_tracker/providers/openai/usage_extractor"
+      autoload :ResponseParser, "llm_cost_tracker/providers/openai/response_parser"
+    end
+
+    module OpenaiCompatible
+      autoload :Parser, "llm_cost_tracker/providers/openai_compatible/parser"
+    end
+  end
+end

data/lib/llm_cost_tracker/railtie.rb

@@ -13,12 +13,9 @@ module LlmCostTracker
       require_relative "generators/llm_cost_tracker/prices_generator"
       require_relative "generators/llm_cost_tracker/call_rollups_generator"
       require_relative "generators/llm_cost_tracker/async_ingestion_generator"
-      require_relative "generators/llm_cost_tracker/reconciliation_generator"
       require_relative "generators/llm_cost_tracker/upgrade_call_rollups_provider_generator"
       require_relative "generators/llm_cost_tracker/upgrade_image_tokens_generator"
       require_relative "generators/llm_cost_tracker/upgrade_call_tags_key_value_index_generator"
-      require_relative "generators/llm_cost_tracker/upgrade_provider_invoice_imports_provider_generator"
-      require_relative "generators/llm_cost_tracker/upgrade_provider_invoices_metadata_index_generator"
     end
   end
 end

data/lib/llm_cost_tracker/report/data.rb

@@ -2,11 +2,11 @@
 
 require "active_support/core_ext/integer/time"
 
-require_relative "../billing/cost_status"
+require_relative "../charges/cost_status"
 require_relative "../ledger"
 
 module LlmCostTracker
-  class Report
+  module Report
     Data = ::Data.define(
       :days,
       :from_time,
@@ -58,8 +58,7 @@ module LlmCostTracker
             "COALESCE(SUM(total_cost), 0) AS total_cost, " \
             "COUNT(*) AS requests_count, " \
             "AVG(latency_ms) AS average_latency_ms, " \
-            "COALESCE(SUM(CASE WHEN total_cost IS NULL " \
-            "OR cost_status IN ('#{Billing::CostStatus::UNKNOWN}', '#{Billing::CostStatus::PARTIAL}') " \
+            "COALESCE(SUM(CASE WHEN #{Charges::CostStatus.unknown_pricing_sql} " \
             "THEN 1 ELSE 0 END), 0) AS unknown_pricing_count"
           )
           .take

data/lib/llm_cost_tracker/report/formatter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  class Report
+  module Report
     class Formatter
       TOP_LIMIT = 5
       MIN_COLUMN_WIDTH = 28

data/lib/llm_cost_tracker/report.rb

@@ -4,7 +4,7 @@ require_relative "report/data"
 require_relative "report/formatter"
 
 module LlmCostTracker
-  class Report
+  module Report
     class << self
       def generate(days: Data::DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil)
         report_data = Data.build(

data/lib/llm_cost_tracker/retention.rb

@@ -21,17 +21,6 @@ module LlmCostTracker
         deleted
       end
 
-      def prune_invoice_imports(older_than:, now: Time.now.utc)
-        cutoff = resolve_cutoff(older_than, now)
-        require_relative "ledger"
-        return 0 unless LlmCostTracker::ProviderInvoiceImport.table_exists?
-
-        LlmCostTracker::ProviderInvoiceImport
-          .where(state: %w[completed failed])
-          .where(finished_at: ...cutoff)
-          .delete_all
-      end
-
       def prune_inbox(older_than:, now: Time.now.utc)
         cutoff = resolve_cutoff(older_than, now)
         require_relative "ingestion"
@@ -70,23 +59,21 @@ module LlmCostTracker
       def prune_batch(cutoff, batch_size)
         LlmCostTracker::Call.transaction do
           cache_rollups = LlmCostTracker.configuration.cache_rollups
-          rows = pluck_prunable(cutoff, batch_size, with_rollup_columns: cache_rollups)
+          rows = prunable_rows(cutoff, batch_size, with_rollup_columns: cache_rollups)
           next 0 if rows.empty?
 
-          ids = cache_rollups ? rows.map(&:first) : rows
+          ids = cache_rollups ? rows.map(&:id) : rows
           deleted = LlmCostTracker::Call.where(id: ids).delete_all
           LlmCostTracker::Ledger::Rollups.decrement!(rows) if cache_rollups && deleted.positive?
           deleted
         end
       end
 
-      def pluck_prunable(cutoff, batch_size, with_rollup_columns:)
+      def prunable_rows(cutoff, batch_size, with_rollup_columns:)
         relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
-        if with_rollup_columns
-          relation.pluck(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider)
-        else
-          relation.pluck(:id)
-        end
+        return relation.pluck(:id) unless with_rollup_columns
+
+        relation.select(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider).to_a
       end
     end
   end

data/lib/llm_cost_tracker/tags/context.rb

@@ -17,14 +17,17 @@ module LlmCostTracker
         end
 
         def tags
-          default_tags = LlmCostTracker.configuration.default_tags
-          default_tags = default_tags.call if default_tags.respond_to?(:call)
-
-          Sanitizer.call(default_tags.to_h).merge(*Array(ActiveSupport::IsolatedExecutionState[KEY]))
+          config = LlmCostTracker.configuration
+          base = config.static_sanitized_default_tags ||
+                 Sanitizer.call(call_default_tags(config.default_tags).to_h)
+          base.merge(*Array(ActiveSupport::IsolatedExecutionState[KEY]))
         end
 
-        def clear!
-          ActiveSupport::IsolatedExecutionState[KEY] = []
+        def call_default_tags(proc_or_lambda)
+          proc_or_lambda.call
+        rescue StandardError => e
+          Logging.warn("LlmCostTracker default_tags proc raised: #{e.class}: #{e.message}; using empty default tags")
+          {}
         end
       end
     end

data/lib/llm_cost_tracker/tags/sanitizer.rb

@@ -27,10 +27,20 @@ module LlmCostTracker
           limit = [config.max_tag_value_bytesize.to_i, 0].max
           max_count = [config.max_tag_count.to_i, 0].max
           tags.to_a.last(max_count).each_with_object({}) do |(key, value), sanitized|
+            next unless valid_key?(key)
+
             sanitized[key] = sanitized_value(key, value, redacted, limit)
           end
         end
 
+        def valid_key?(key)
+          Tags::Key.validate!(key)
+          true
+        rescue ArgumentError => e
+          Logging.warn("LlmCostTracker tag key invalid: #{e.message}; skipping")
+          false
+        end
+
         def cap(tags, config: LlmCostTracker.configuration)
           tags = (tags || {}).to_h
           max_count = [config.max_tag_count.to_i, 0].max

data/lib/llm_cost_tracker/timing.rb

@@ -2,13 +2,11 @@
 
 module LlmCostTracker
   module Timing
-    module_function
-
-    def now_monotonic
+    def self.now_monotonic
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def elapsed_ms(started_at)
+    def self.elapsed_ms(started_at)
       ((now_monotonic - started_at) * 1000).round
     end
   end

data/lib/llm_cost_tracker/tracker.rb

@@ -1,47 +1,46 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
+require "active_support/notifications"
 require "securerandom"
 
 require_relative "ingestion"
 require_relative "ledger"
-require_relative "logging"
 require_relative "pricing"
-require_relative "billing/cost_status"
 
 module LlmCostTracker
-  class Tracker
+  module Tracker
     EVENT_NAME = "llm_request.llm_cost_tracker"
 
     class << self
-      def enforce_budget!(provider: nil, model: nil, request: nil)
+      def record(event:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil, enforce_budget: false)
         return unless LlmCostTracker.configuration.enabled
 
-        Budget.enforce!(provider: provider, model: model, request: request)
-      end
-
-      def record(event:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil)
-        return unless LlmCostTracker.configuration.enabled
-
-        pricing_mode = Pricing::Mode.normalize(pricing_mode) || event.pricing_mode
-        cost_data, pricing_snapshot, priced_line_items = Pricing.calculate(
+        pricing_mode ||= event.pricing_mode
+        calculation = Pricing::Calculation.for(
           provider: event.provider,
           model: event.model,
           tokens: event.token_usage,
           line_items: event.line_items,
-          pricing_mode: pricing_mode
+          pricing_mode: pricing_mode,
+          usage_source: event.usage_source
         )
 
-        if cost_data.nil? && event.token_usage.total_tokens.positive? && priced_line_items.none?(&:priced?)
+        if enforce_budget
+          Budget.enforce!(provider: event.provider,
+                          model: event.model,
+                          estimate: calculation.cost&.total,
+                          force: true)
+        end
+
+        if calculation.token_cost.nil? && event.token_usage.total_tokens.positive? &&
+           calculation.priced_line_items.none?(&:priced?)
           Pricing::Unknown.process(event.model)
         end
 
         event = build_event(
           event: event,
-          pricing_mode: pricing_mode,
-          cost_data: cost_data,
-          pricing_snapshot: pricing_snapshot,
-          line_items: priced_line_items,
+          calculation: calculation,
           metadata: metadata,
           latency_ms: latency_ms,
           context_tags: context_tags
@@ -51,7 +50,7 @@ module LlmCostTracker
           Ingestion::Inbox.save(event)
           Ingestion::Worker.ensure_started
         else
-          Ledger::Store.insert(event, skip_existence_check: true)
+          Ledger::Store.insert(event)
         end
 
         yield if block_given?
@@ -71,29 +70,18 @@ module LlmCostTracker
         Logging.warn("Subscriber raised on #{EVENT_NAME}: #{e.class}: #{e.message}")
       end
 
-      def build_event(event:, pricing_mode:, cost_data:, pricing_snapshot:, line_items:,
-                      metadata:, latency_ms:, context_tags:)
+      def build_event(event:, calculation:, metadata:, latency_ms:, context_tags:)
         context_tags = (context_tags || LlmCostTracker::Tags::Context.tags).to_h
-        cost = Pricing.combine_with_service_lines(cost_data, line_items)
-        cost_status = Billing::CostStatus.call(
-          token_usage: event.token_usage,
-          usage_source: event.usage_source,
-          token_cost: cost_data,
-          token_pricing_partial: Pricing.token_pricing_partial?(event.token_usage, cost_data),
-          service_line_items: line_items.reject(&:token?),
-          total_cost: cost&.fetch(:total_cost, nil)
-        )
-
         event.with(
           event_id: SecureRandom.uuid,
-          pricing_mode: pricing_mode,
-          cost: cost,
+          pricing_mode: calculation.mode,
+          cost: calculation.cost,
           tags: build_tags(context_tags: context_tags, metadata: metadata),
           latency_ms: finite_latency_ms(latency_ms),
           tracked_at: Time.now.utc,
-          cost_status: cost_status,
-          pricing_snapshot: pricing_snapshot,
-          line_items: line_items
+          cost_status: calculation.cost_status,
+          pricing_snapshot: calculation.snapshot,
+          line_items: calculation.priced_line_items
         )
       end
 

data/lib/llm_cost_tracker/usage/catalog.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require "psych"
+
+require_relative "dimension"
+
+module LlmCostTracker
+  module Usage
+    module Catalog
+      DEFINITIONS_PATH = File.expand_path("dimensions.yml", __dir__)
+
+      DEFAULT_RATE_BASIS_BY_UNIT = {
+        "token" => "per_million_tokens",
+        "character" => "per_million_characters",
+        "request" => "per_request",
+        "session" => "per_session",
+        "hour" => "per_hour",
+        "minute" => "per_minute",
+        "image" => "per_image"
+      }.freeze
+
+      class << self
+        delegate :[], :fetch, to: :index
+
+        def all
+          @all ||= load_definitions.freeze
+        end
+
+        def token_priced
+          @token_priced ||= all.select(&:token_key).freeze
+        end
+
+        def token_priced_for(kind:, direction:, cache_state:)
+          token_priced.find do |dimension|
+            dimension.kind == kind && dimension.direction == direction && dimension.cache_state == cache_state
+          end
+        end
+
+        private
+
+        def index
+          @index ||= all.to_h { |dimension| [dimension.key, dimension] }.freeze
+        end
+
+        def load_definitions
+          Psych.safe_load_file(DEFINITIONS_PATH, permitted_classes: [], symbolize_names: true)
+               .map { |attributes| build(attributes) }
+        end
+
+        def build(attributes)
+          rate_basis = attributes[:rate_basis] || DEFAULT_RATE_BASIS_BY_UNIT.fetch(attributes.fetch(:unit))
+          Dimension.new(**attributes, rate_basis: rate_basis)
+        end
+      end
+    end
+  end
+end