llm_cost_tracker 0.14.1 → 0.14.2

data/lib/llm_cost_tracker/ledger/schema/base.rb

@@ -21,10 +21,11 @@ module LlmCostTracker
         end
 
         def current_schema_errors
-          connection = model.connection
-          Adapter.ensure_supported!(connection)
-          table_name = model.table_name
-          return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
+          Adapter.ensure_supported!(model.connection)
+          unless model.table_exists?
+            model.connection.schema_cache.clear_data_source_cache!(model.table_name)
+            return ["#{model.table_name} table is missing"] unless model.table_exists?
+          end
 
           columns_hash = model.columns_hash
           cache = @schema_capabilities

data/lib/llm_cost_tracker/ledger/store.rb

@@ -118,10 +118,10 @@ module LlmCostTracker
 
         def insert_call_tags(events, call_ids)
           rows = events.flat_map do |event|
-            (event.tags || {}).map do |key, value|
+            (event.tags || {}).to_h { |key, value| [key.to_s, value] }.map do |key, value|
               {
                 llm_cost_tracker_call_id: call_ids.fetch(event.event_id),
-                key: key.to_s,
+                key: key,
                 value: Tags::Encoding.encode(Storable.clean(value))
               }.merge(budget_columns_for(event))
             end

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

@@ -19,7 +19,7 @@ module LlmCostTracker
           end
 
           def value_arel
-            Arel.sql("#{call_tag_table}.#{quote_column('value')}")
+            Arel.sql(raw_value_sql(LlmCostTracker::CallTag.connection))
           end
 
           def label_sql(connection)
@@ -35,10 +35,6 @@ module LlmCostTracker
           def call_tag_table
             LlmCostTracker::CallTag.quoted_table_name
           end
-
-          def quote_column(name)
-            LlmCostTracker::CallTag.connection.quote_column_name(name)
-          end
         end
       end
     end

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

@@ -10,8 +10,7 @@ module LlmCostTracker
 
         def self.encode(value)
           encoded = case value
-                    when Hash then JSON.generate(normalize_hash(value))
-                    when Array then JSON.generate(normalize_array(value))
+                    when Hash, Array then JSON.generate(normalize_value(value))
                     else value.to_s
                     end
           truncate(encoded)
@@ -24,18 +23,10 @@ module LlmCostTracker
           string.byteslice(0, limit).encode("UTF-8", invalid: :replace, undef: :replace)
         end
 
-        def self.normalize_hash(hash)
-          hash.transform_keys(&:to_s).sort.to_h.transform_values { |v| normalize_value(v) }
-        end
-
-        def self.normalize_array(array)
-          array.map { |v| normalize_value(v) }
-        end
-
         def self.normalize_value(value)
           case value
-          when Hash then normalize_hash(value)
-          when Array then normalize_array(value)
+          when Hash then value.transform_keys(&:to_s).sort.to_h.transform_values { |v| normalize_value(v) }
+          when Array then value.map { |v| normalize_value(v) }
           else value.to_s
           end
         end

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

@@ -9,8 +9,6 @@ module LlmCostTracker
         class << self
           def apply(tags)
             normalized_tags = (tags || {}).to_h.transform_keys(&:to_s).transform_values { |v| Encoding.encode(v) }
-            return LlmCostTracker::Call.all if normalized_tags.empty?
-
             normalized_tags.inject(LlmCostTracker::Call.all) do |relation, (key, value)|
               relation.where(id: LlmCostTracker::CallTag.where(key: key,
                                                                value: value).select(:llm_cost_tracker_call_id))

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -11,6 +11,8 @@ require_relative "../timing"
 module LlmCostTracker
   module Middleware
     class Faraday < ::Faraday::Middleware
+      MULTIPART_MODEL = /name="model"\r\n(?:[^\r\n]+\r\n)*\r\n([^\r\n]+)\r\n/
+
       def initialize(app, **options)
         super(app)
         @tags = options.fetch(:tags, {})
@@ -20,8 +22,8 @@ module LlmCostTracker
         return @app.call(request_env) unless LlmCostTracker.configuration.enabled
 
         request_url  = request_env.url.to_s
-        request_body = read_body(request_env.body)
         parser       = Parsers.find_for(request_url)
+        request_body = read_body(request_env.body) || multipart_model_body(request_env, parser)
         request_parsed = parser&.safe_json_parse(request_body)
         streaming = parser&.streaming_request?(request_url, request_parsed)
         if streaming
@@ -29,8 +31,8 @@ module LlmCostTracker
         end
         stream_buffer = install_stream_tap(request_env, parser) if streaming
 
-        if parser
-          context_tags, metadata = tag_snapshot(request_env)
+        context_tags, metadata = tag_snapshot(request_env) if parser
+        if parser && request_env.method == :post
           Budget.enforce!(
             provider: parser.provider_for(request_url),
             model: parser.model_for(request_url, request_parsed),
@@ -72,7 +74,7 @@ module LlmCostTracker
             request_url: request_url,
             request_body: request_body,
             response_env: response_env,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
+            latency_ms: (LlmCostTracker::Timing.elapsed_ms(started_at) if request_env.method == :post),
             streaming: streaming,
             stream_buffer: stream_buffer,
             context_tags: context_tags,
@@ -165,16 +167,12 @@ module LlmCostTracker
               response_env: response_env
             )
           end
-        return unless parsed
 
-        Tracker.record(
-          event: parsed,
-          latency_ms: latency_ms,
-          metadata: metadata,
-          context_tags: context_tags
-        )
+        Tracker.record(event: parsed, latency_ms: latency_ms, metadata: metadata, context_tags: context_tags) if parsed
       rescue *LlmCostTracker::CALLER_ERRORS
         raise
+      rescue ActiveRecord::RecordNotUnique
+        nil
       rescue StandardError => e
         Logging.warn("Error processing response: #{e.class}: #{e.message}")
       end
@@ -261,16 +259,35 @@ module LlmCostTracker
         end
       end
 
+      def multipart_model_body(request_env, parser)
+        body = request_env.body
+        multipart = request_env.request_headers["Content-Type"].to_s.start_with?("multipart/form-data")
+        return nil unless parser && multipart && body.respond_to?(:read) && body.respond_to?(:rewind)
+
+        model = multipart_model(body)
+        model && { "model" => model }.to_json
+      rescue StandardError => e
+        Logging.warn("Unable to read the model from a multipart request: #{e.class}: #{e.message}")
+        nil
+      end
+
+      def multipart_model(body)
+        window = String.new(encoding: Encoding::BINARY)
+        while (chunk = body.read(65_536))
+          window << chunk.b
+          model = window[MULTIPART_MODEL, 1]
+          return model.force_encoding(Encoding::UTF_8) if model
+
+          window = window.byteslice([window.bytesize - 512, 0].max..)
+        end
+      ensure
+        body.rewind
+      end
+
       def resolved_tags(request_env)
-        tags =
-          if @tags.respond_to?(:call)
-            @tags.arity.zero? ? @tags.call : @tags.call(request_env)
-          else
-            @tags
-          end
-        return {} if tags.nil?
+        return @tags.to_h unless @tags.respond_to?(:call)
 
-        tags.to_h
+        (@tags.arity.zero? ? @tags.call : @tags.call(request_env)).to_h
       end
 
       def tag_snapshot(request_env)

data/lib/llm_cost_tracker/parsers.rb

@@ -8,50 +8,27 @@ require_relative "providers"
 
 module LlmCostTracker
   module Parsers
-    PARSER_PROVIDERS = %i[Openai Azure OpenaiCompatible Anthropic Gemini].freeze
+    PARSER_PROVIDERS = %i[Openai Azure Anthropic Gemini OpenaiCompatible].freeze
 
     def self.find_for(url)
-      instances.each do |klass, instance|
-        return instance if klass.match?(url)
-      end
-      nil
+      instances.find { |parser| parser.class.match?(url) }
     end
 
     def self.find_for_provider(provider)
-      provider_name = provider.to_s.downcase
-      instances.each do |klass, instance|
-        return instance if klass.provider_names.include?(provider_name)
-      end
-      nil
+      all_for_provider(provider).first
     end
 
-    def self.parser_classes
-      PARSER_PROVIDERS.map { |name| Providers.const_get(name)::Parser }
+    def self.all_for_provider(provider)
+      provider_name = provider.to_s.downcase
+      instances.select { |parser| parser.class.provider_names.include?(provider_name) }
     end
-    private_class_method :parser_classes
 
     def self.instances
-      @instances ||= parser_classes.to_h { |klass| [klass, klass.new] }.freeze
+      @instances ||= PARSER_PROVIDERS.map { |name| Providers.const_get(name)::Parser.new }.freeze
     end
     private_class_method :instances
 
     module UrlMatchers
-      def match_uri?(url, hosts: nil, exact_paths: nil, path_includes: nil, path_suffixes: nil, path_pattern: nil)
-        uri_matches?(url) do |uri|
-          host_match = hosts.nil? || hosts.include?(uri.host.to_s.downcase)
-          path_match = path_matches?(
-            uri,
-            exact_paths: exact_paths,
-            path_includes: path_includes,
-            path_suffixes: path_suffixes,
-            path_pattern: path_pattern
-          )
-          extra_match = block_given? ? yield(uri) : true
-
-          !!(host_match && path_match && extra_match)
-        end
-      end
-
       def uri_matches?(url)
         uri = parsed_uri(url)
         uri ? yield(uri) : false
@@ -62,16 +39,6 @@ module LlmCostTracker
       rescue URI::InvalidURIError
         nil
       end
-
-      def path_matches?(uri, exact_paths: nil, path_includes: nil, path_suffixes: nil, path_pattern: nil)
-        path = uri.path.to_s
-        matches = true
-        matches &&= exact_paths.include?(path) if exact_paths
-        matches &&= Array(path_includes).all? { |fragment| path.include?(fragment) } if path_includes
-        matches &&= path.match?(path_pattern) if path_pattern
-        matches &&= path_suffixes.any? { |suffix| path == suffix || path.end_with?(suffix) } if path_suffixes
-        matches
-      end
     end
 
     class Base