llm_cost_tracker 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5d394087953583d254479b4fe162adbb5b5a0f4de09c535428d514a6c623e76
-  data.tar.gz: b3269262ceec2e1f622780e3e44ac33adb1df703e077bee43fcddd7c251a21dc
+  metadata.gz: 6950dae400eac9294a57a0ba2fd2bce7977658837962eafffc3836fa4ab9bd2b
+  data.tar.gz: c398f5271d3d0fa53cb27e1206e418e0242fb9dff73ed2c405903b92dfaf8a48
 SHA512:
-  metadata.gz: 93ce84108bea091e89df70b28a192e280a1e3de92bdb14b8d47ca4057527ebcd4ec1ffa25fc37fc5216df4804539f5b1b9483d6f1fb1afdd292fd19e836431e5
-  data.tar.gz: f69fed55512f322118e93493b9069821e3cd9b372940b6163b7f80578afc3b95799126b91178b25125c7eba871ebe8b3a8fd32e607f8103649c1f3d4d606923d
+  metadata.gz: c52638e31e7eb0f46308312339bd40cfce87227a8c7ec77c94b3af08ffc931c3cffb9566f2ce15ec70a87700084e5e9bb6d05fe670028b57a12066af4a9ebaf6
+  data.tar.gz: 12da45f4cd8c485bd6fde5f9376bdfa2c8e618abd41e7be11c022878ec005348ca5d98578216170f1b7105dcc9e2c0c4b037cb5394e2085e2526e04ee8d5a885

data/CHANGELOG.md

@@ -4,6 +4,12 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [S
 
 ## [Unreleased]
 
+## [0.7.3] - 2026-05-01
+
+### Fixed
+
+- Gemini API thinking tokens no longer get added to output tokens twice.
+
 ## [0.7.2] - 2026-05-01
 
 ### Added

data/README.md

@@ -1,12 +1,12 @@
 # LLM Cost Tracker
 
-A Rails-native ledger for what your LLM calls actually cost.
+A Rails-native ledger for estimating LLM API spend.
 
 [![Gem Version](https://img.shields.io/gem/v/llm_cost_tracker.svg)](https://rubygems.org/gems/llm_cost_tracker)
 [![CI](https://github.com/sergey-homenko/llm_cost_tracker/actions/workflows/ruby.yml/badge.svg)](https://github.com/sergey-homenko/llm_cost_tracker/actions)
 [![codecov](https://codecov.io/gh/sergey-homenko/llm_cost_tracker/branch/main/graph/badge.svg)](https://codecov.io/gh/sergey-homenko/llm_cost_tracker)
 
-If you have OpenAI, Anthropic, or Gemini in production and someone keeps asking "where did that bill come from?", this gem records every call into your own database, prices it locally, and gives you a dashboard you can mount in five minutes. No proxy, no SaaS account, no extra service to deploy.
+If someone keeps asking "where did that LLM bill come from?", this gem records provider-reported usage into your own database, prices it locally, and gives you a dashboard you can mount in five minutes. No proxy, no SaaS account, no extra service to deploy.
 
 It is not Langfuse, Helicone, or LiteLLM. It does not capture prompts, score completions, or replay traces. It does one thing: tells you which provider, which model, which feature, and which user burned how much money. That's the entire pitch.
 
@@ -14,6 +14,10 @@ Requires Ruby 3.3+, Rails 7.1+, PostgreSQL or MySQL, and Faraday 2.0+.
 
 ![Dashboard overview](docs/dashboard-overview.png)
 
+## Accuracy model
+
+LLM Cost Tracker estimates spend from provider-reported usage and configured prices. It is useful for explaining spend by provider, model, and tags, but it is not invoice-grade billing. For reconciliation, each call keeps `provider_response_id`, `usage_source`, token breakdowns, and `pricing_mode`.
+
 ## Quickstart
 
 Add to your Gemfile alongside whatever LLM client you already use:

data/app/models/llm_cost_tracker/ledger/call.rb

@@ -38,7 +38,7 @@ module LlmCostTracker
       end
 
       def self.by_tags(tags)
-        Ledger::Tags::Query.apply(self, tags)
+        Ledger::Tags::Query.apply(tags)
       end
     end
   end

data/app/models/llm_cost_tracker/ledger/call_metrics.rb

@@ -48,7 +48,7 @@ module LlmCostTracker
       end
 
       def tag_value_expression(key, table_name: quoted_table_name)
-        Ledger::Tags::Sql.value_expression(self, key, table_name: table_name)
+        Ledger::Tags::Sql.value_expression(key, table_name: table_name)
       end
 
       private

data/app/services/llm_cost_tracker/dashboard/data_quality.rb

@@ -8,8 +8,7 @@ module LlmCostTracker
     class DataQuality
       class << self
         def call(scope: LlmCostTracker::Ledger::Call.all)
-          model = scope.klass
-          scope.unscope(:order).select(aggregate_selects(scope, model:)).take
+          scope.unscope(:order).select(aggregate_selects(scope)).take
         end
 
         def unknown_pricing_by_model(scope)
@@ -70,12 +69,12 @@ module LlmCostTracker
 
         private
 
-        def aggregate_selects(scope, model:)
+        def aggregate_selects(scope)
           selects = [
             "COUNT(*) AS total_calls",
             "#{conditional_count_sql('total_cost IS NULL')} AS unknown_pricing_count",
-            "#{tagged_calls_sql(model)} AS tagged_calls_count",
-            "COUNT(*) - #{tagged_calls_sql(model)} AS untagged_calls_count",
+            "#{tagged_calls_sql(scope)} AS tagged_calls_count",
+            "COUNT(*) - #{tagged_calls_sql(scope)} AS untagged_calls_count",
             "#{conditional_count_sql('latency_ms IS NULL')} AS missing_latency_count",
             "#{conditional_count_sql('stream')} AS streaming_count",
             "#{streaming_missing_usage_select} AS streaming_missing_usage_count",
@@ -127,11 +126,12 @@ module LlmCostTracker
           conditional_count_sql(predicate)
         end
 
-        def tagged_calls_sql(model)
-          table = model.quoted_table_name
-          column = "#{table}.#{model.connection.quote_column_name('tags')}"
+        def tagged_calls_sql(scope)
+          table = scope.klass.quoted_table_name
+          connection = scope.connection
+          column = "#{table}.#{connection.quote_column_name('tags')}"
 
-          if Ledger::Schema::Adapter.postgresql?(model.connection)
+          if Ledger::Schema::Adapter.postgresql?(connection)
             "COALESCE(SUM(CASE WHEN #{column} <> '{}'::jsonb THEN 1 ELSE 0 END), 0)"
           else
             "COALESCE(SUM(CASE WHEN JSON_LENGTH(#{column}) > 0 THEN 1 ELSE 0 END), 0)"

data/lib/llm_cost_tracker/ledger/rollups/upsert_sql.rb

@@ -6,12 +6,8 @@ module LlmCostTracker
   module Ledger
     class Rollups
       class UpsertSql
-        def self.call(model)
-          new(model).call
-        end
-
-        def initialize(model)
-          @model = model
+        def self.call
+          new.call
         end
 
         def call
@@ -23,13 +19,11 @@ module LlmCostTracker
 
         private
 
-        attr_reader :model
-
         def postgres_sql
           total_cost = connection.quote_column_name("total_cost")
           updated_at = connection.quote_column_name("updated_at")
 
-          "#{total_cost} = #{model.quoted_table_name}.#{total_cost} + excluded.#{total_cost}, " \
+          "#{total_cost} = #{Period::Total.quoted_table_name}.#{total_cost} + excluded.#{total_cost}, " \
             "#{updated_at} = excluded.#{updated_at}"
         end
 
@@ -38,7 +32,7 @@ module LlmCostTracker
         end
 
         def connection
-          model.connection
+          Period::Total.connection
         end
       end
     end

data/lib/llm_cost_tracker/ledger/rollups.rb

@@ -15,9 +15,9 @@ module LlmCostTracker
 
           Period::Total.upsert_all(
             period_rows(event),
-            on_duplicate: Ledger::Rollups::UpsertSql.call(Period::Total),
+            on_duplicate: Ledger::Rollups::UpsertSql.call,
             record_timestamps: true,
-            unique_by: unique_by(Period::Total, %i[period period_start])
+            unique_by: period_totals_unique_by
           )
         end
 
@@ -27,9 +27,9 @@ module LlmCostTracker
 
           Period::Total.upsert_all(
             Ledger::Rollups::Batch.rows(events),
-            on_duplicate: Ledger::Rollups::UpsertSql.call(Period::Total),
+            on_duplicate: Ledger::Rollups::UpsertSql.call,
             record_timestamps: true,
-            unique_by: unique_by(Period::Total, %i[period period_start])
+            unique_by: period_totals_unique_by
           )
         end
 
@@ -76,10 +76,10 @@ module LlmCostTracker
           end
         end
 
-        def unique_by(model, column)
-          return unless model.connection.supports_insert_conflict_target?
+        def period_totals_unique_by
+          return unless Period::Total.connection.supports_insert_conflict_target?
 
-          column
+          %i[period period_start]
         end
       end
     end

data/lib/llm_cost_tracker/ledger/store.rb

@@ -11,12 +11,11 @@ module LlmCostTracker
           events = Array(events)
           return [] if events.empty?
 
-          model = LlmCostTracker::Ledger::Call
-          insertable = new_events(model, events)
+          insertable = insertable_events(events)
 
           if insertable.any?
             rows = insertable.map { |event| attributes_for(event) }
-            model.insert_all!(rows, record_timestamps: true, returning: false)
+            Ledger::Call.insert_all!(rows, record_timestamps: true, returning: false)
             Ledger::Rollups.increment_many!(insertable)
           end
           events
@@ -25,14 +24,11 @@ module LlmCostTracker
         private
 
         def attributes_for(event)
-          tags = (event.tags || {}).transform_keys(&:to_s).transform_values { |value| stringify_tag_value(value) }
-          usage = event.token_usage.stored_attributes
-
           attributes = {
             event_id: event.event_id,
             provider: event.provider,
             model: event.model,
-            tags: tags,
+            tags: stored_tags(event.tags),
             tracked_at: event.tracked_at,
             pricing_mode: event.pricing_mode,
             latency_ms: event.latency_ms,
@@ -41,16 +37,29 @@ module LlmCostTracker
             provider_response_id: event.provider_response_id
           }
 
-          attributes.merge(usage).merge(Pricing.stored_cost_attributes(event.cost || {}))
+          attributes
+            .merge(event.token_usage.stored_attributes)
+            .merge(Pricing.stored_cost_attributes(event.cost || {}))
+        end
+
+        def insertable_events(events)
+          existing_ids = Ledger::Call.where(event_id: events.map(&:event_id)).pluck(:event_id).to_set
+          seen_ids = Set.new
+
+          events.select do |event|
+            event_id = event.event_id
+            !existing_ids.include?(event_id) && seen_ids.add?(event_id)
+          end
         end
 
-        def new_events(model, events)
-          existing_ids = model.where(event_id: events.map(&:event_id)).pluck(:event_id).to_set
-          events.reject { |event| existing_ids.include?(event.event_id) }
+        def stored_tags(tags)
+          (tags || {}).transform_keys(&:to_s).transform_values { |value| stored_tag_value(value) }
         end
 
-        def stringify_tag_value(value)
-          return value.transform_values { |nested| stringify_tag_value(nested) } if value.is_a?(Hash)
+        def stored_tag_value(value)
+          if value.is_a?(Hash)
+            return value.transform_keys(&:to_s).transform_values { |nested| stored_tag_value(nested) }
+          end
 
           value.to_s
         end

data/lib/llm_cost_tracker/ledger/tags/query.rb

@@ -9,17 +9,17 @@ module LlmCostTracker
     module Tags
       module Query
         class << self
-          def apply(model, tags)
+          def apply(tags)
             normalized_tags = (tags || {}).to_h.transform_keys(&:to_s).transform_values(&:to_s)
-            return model.all if normalized_tags.empty?
+            return Ledger::Call.all if normalized_tags.empty?
 
-            connection = model.connection
+            connection = Ledger::Call.connection
             json = normalized_tags.to_json
 
             if Schema::Adapter.postgresql?(connection)
-              model.where("tags @> ?::jsonb", json)
+              Ledger::Call.where("tags @> ?::jsonb", json)
             else
-              model.where("JSON_CONTAINS(tags, ?)", json)
+              Ledger::Call.where("JSON_CONTAINS(tags, ?)", json)
             end
           end
         end

data/lib/llm_cost_tracker/ledger/tags/sql.rb

@@ -8,16 +8,17 @@ module LlmCostTracker
     module Tags
       module Sql
         class << self
-          def value_expression(model, key, table_name:)
+          def value_expression(key, table_name:)
             key = LlmCostTracker::Tags::Key.validate!(key)
-            column = "#{table_name}.#{model.connection.quote_column_name('tags')}"
+            connection = Ledger::Call.connection
+            column = "#{table_name}.#{connection.quote_column_name('tags')}"
 
-            if Ledger::Schema::Adapter.postgresql?(model.connection)
-              "#{column}->>#{model.connection.quote(key)}"
-            elsif Ledger::Schema::Adapter.mysql?(model.connection)
-              "JSON_UNQUOTE(JSON_EXTRACT(#{column}, #{model.connection.quote(json_path(key))}))"
+            if Ledger::Schema::Adapter.postgresql?(connection)
+              "#{column}->>#{connection.quote(key)}"
+            elsif Ledger::Schema::Adapter.mysql?(connection)
+              "JSON_UNQUOTE(JSON_EXTRACT(#{column}, #{connection.quote(json_path(key))}))"
             else
-              Ledger::Schema::Adapter.ensure_supported!(model.connection)
+              Ledger::Schema::Adapter.ensure_supported!(connection)
             end
           end
 

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -100,7 +100,7 @@ module LlmCostTracker
       end
 
       def output_tokens(usage)
-        usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
+        usage["candidatesTokenCount"].to_i
       end
 
       def total_tokens(usage:, cache_read:, tool_use_prompt:)

data/lib/llm_cost_tracker/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors:
 - Sergii Khomenko