llm_cost_tracker 0.7.1 → 0.7.2

data/lib/llm_cost_tracker/pricing/lookup.rb

@@ -22,10 +22,27 @@ module LlmCostTracker
           current = current_price_tables
 
           match =
-            explain_table(current.fetch(:pricing_overrides), :pricing_overrides, provider_model, model_name,
-                          normalized_model) ||
-            explain_table(current.fetch(:file_prices), :prices_file, provider_model, model_name, normalized_model) ||
-            explain_table(Registry.builtin_prices, :bundled, provider_model, model_name, normalized_model)
+            explain_table(
+              table: current.fetch(:pricing_overrides),
+              source: :pricing_overrides,
+              provider_model: provider_model,
+              model_name: model_name,
+              normalized_model: normalized_model
+            ) ||
+            explain_table(
+              table: current.fetch(:file_prices),
+              source: :prices_file,
+              provider_model: provider_model,
+              model_name: model_name,
+              normalized_model: normalized_model
+            ) ||
+            explain_table(
+              table: Registry.builtin_prices,
+              source: :bundled,
+              provider_model: provider_model,
+              model_name: model_name,
+              normalized_model: normalized_model
+            )
           cache_lookup(cache_key, match)
           match
         end
@@ -74,46 +91,51 @@ module LlmCostTracker
           end
         end
 
-        def explain_table(table, source, provider_model, model_name, normalized_model)
+        def explain_table(table:, source:, provider_model:, model_name:, normalized_model:)
           return nil if table.empty?
 
-          direct_match(table, source, provider_model, :provider_model) ||
-            direct_match(table, source, model_name, :model) ||
-            direct_match(table, source, normalized_model, :normalized_model) ||
-            unique_providerless_lookup(normalized_model, table, source) ||
-            fuzzy_match(provider_model, normalized_model, table, source) ||
-            unique_providerless_fuzzy_match(normalized_model, table, source)
+          direct_match(table: table, source: source, key: provider_model, matched_by: :provider_model) ||
+            direct_match(table: table, source: source, key: model_name, matched_by: :model) ||
+            direct_match(table: table, source: source, key: normalized_model, matched_by: :normalized_model) ||
+            unique_providerless_lookup(model: normalized_model, table: table, source: source) ||
+            fuzzy_match(model: provider_model, normalized_model: normalized_model, table: table, source: source) ||
+            unique_providerless_fuzzy_match(model: normalized_model, table: table, source: source)
         end
 
         def normalize_model_name(model)
           model.to_s.split("/").last
         end
 
-        def unique_providerless_lookup(model, table, source)
+        def unique_providerless_lookup(model:, table:, source:)
           matches = sorted_price_keys(table).select { |key| normalize_model_name(key) == model }
-          match(table, source, matches.first, :unique_providerless_model) if matches.one?
+          return unless matches.one?
+
+          match(table: table, source: source, key: matches.first, matched_by: :unique_providerless_model)
         end
 
-        def fuzzy_match(model, normalized_model, table, source)
+        def fuzzy_match(model:, normalized_model:, table:, source:)
           sorted_price_keys(table).each do |key|
-            return match(table, source, key, :dated_snapshot) if snapshot_variant?(model, key) ||
-                                                                 snapshot_variant?(normalized_model, key)
+            if snapshot_variant?(model, key) || snapshot_variant?(normalized_model, key)
+              return match(table: table, source: source, key: key, matched_by: :dated_snapshot)
+            end
           end
 
           nil
         end
 
-        def unique_providerless_fuzzy_match(model, table, source)
+        def unique_providerless_fuzzy_match(model:, table:, source:)
           matches = sorted_price_keys(table).select { |key| snapshot_variant?(model, normalize_model_name(key)) }
-          match(table, source, matches.first, :unique_providerless_dated_snapshot) if matches.one?
+          return unless matches.one?
+
+          match(table: table, source: source, key: matches.first, matched_by: :unique_providerless_dated_snapshot)
         end
 
-        def direct_match(table, source, key, matched_by)
-          match(table, source, key, matched_by) if table.key?(key)
+        def direct_match(table:, source:, key:, matched_by:)
+          match(table: table, source: source, key: key, matched_by: matched_by) if table.key?(key)
         end
 
-        def match(table, source, key, matched_by)
-          Match.new(source.to_s, key, table[key], matched_by.to_s)
+        def match(table:, source:, key:, matched_by:)
+          Match.new(source: source.to_s, key: key, prices: table[key], matched_by: matched_by.to_s)
         end
 
         def snapshot_variant?(model, key)

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -43,12 +43,28 @@ module LlmCostTracker
           response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
 
           if response.not_modified
-            return refresh_result(path, url, response, current, current, written: false, not_modified: true)
+            return refresh_result(
+              path: path,
+              url: url,
+              response: response,
+              current: current,
+              remote: current,
+              written: false,
+              not_modified: true
+            )
           end
 
           remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
           RegistryWriter.new.call(path: path, registry: remote) unless preview
-          refresh_result(path, url, response, current, remote, written: !preview, not_modified: false)
+          refresh_result(
+            path: path,
+            url: url,
+            response: response,
+            current: current,
+            remote: remote,
+            written: !preview,
+            not_modified: false
+          )
         end
 
         def check(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, fetcher: Fetcher.new, today: Date.today)
@@ -127,7 +143,7 @@ module LlmCostTracker
           raise Error, "Unable to parse remote pricing snapshot: #{e.message}"
         end
 
-        def refresh_result(path, url, response, current, remote, written:, not_modified:)
+        def refresh_result(path:, url:, response:, current:, remote:, written:, not_modified:)
           RefreshResult.new(
             path: path,
             source_url: url,

data/lib/llm_cost_tracker/tracker.rb

@@ -21,7 +21,7 @@ module LlmCostTracker
         Budget.enforce!
       end
 
-      def record(capture:, latency_ms: nil, pricing_mode: nil, metadata: {})
+      def record(capture:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil)
         return unless LlmCostTracker.configuration.enabled
 
         pricing_mode = Pricing.normalize_mode(pricing_mode) || capture.pricing_mode
@@ -39,7 +39,8 @@ module LlmCostTracker
           pricing_mode: pricing_mode,
           cost_data: cost_data,
           metadata: metadata,
-          latency_ms: latency_ms
+          latency_ms: latency_ms,
+          context_tags: context_tags
         )
 
         ActiveSupport::Notifications.instrument(EVENT_NAME, event.to_h)
@@ -52,7 +53,7 @@ module LlmCostTracker
 
       private
 
-      def build_event(capture:, pricing_mode:, cost_data:, metadata:, latency_ms:)
+      def build_event(capture:, pricing_mode:, cost_data:, metadata:, latency_ms:, context_tags:)
         usage_source = if capture.usage_source.nil?
                          nil
                        else
@@ -60,6 +61,7 @@ module LlmCostTracker
                          USAGE_SOURCES.include?(symbol) ? symbol.to_s : nil
                        end
         tags = metadata.to_h.reject { |key, _value| TRACKING_METADATA_KEYS.include?(key.to_s) }
+        context_tags = context_tags.nil? ? LlmCostTracker::Tags::Context.tags : context_tags.to_h
 
         Event.new(
           event_id: SecureRandom.uuid,
@@ -69,7 +71,7 @@ module LlmCostTracker
           pricing_mode: pricing_mode,
           cost: cost_data,
           tags: LlmCostTracker::Tags::Sanitizer.call(
-            LlmCostTracker::Tags::Context.tags.merge(tags)
+            context_tags.merge(tags)
           ).freeze,
           latency_ms: latency_ms.nil? ? nil : [latency_ms.to_i, 0].max,
           stream: capture.stream ? true : false,

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Sergii Khomenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-30 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord