llm_cost_tracker 0.6.1 → 0.7.1

data/lib/llm_cost_tracker/tag_sanitizer.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module LlmCostTracker
-  module TagSanitizer
-    REDACTED_VALUE = "[REDACTED]"
-
-    class << self
-      def call(tags, config: LlmCostTracker.configuration)
-        tags = (tags || {}).to_h
-        tags.first(max_tag_count(config)).each_with_object({}) do |(key, value), sanitized|
-          sanitized[key] = sanitized_value(key, value, config)
-        end
-      end
-
-      private
-
-      def sanitized_value(key, value, config)
-        return REDACTED_VALUE if redacted_key?(key, config)
-
-        string = value_string(value)
-        return value if string.bytesize <= max_tag_value_bytesize(config)
-
-        truncate_bytes(string, max_tag_value_bytesize(config))
-      end
-
-      def redacted_key?(key, config)
-        normalized = normalized_key(key)
-        redacted_keys(config).any? do |candidate|
-          redacted_key_component?(normalized, candidate)
-        end
-      end
-
-      def redacted_keys(config)
-        Array(config.redacted_tag_keys).map { |key| normalized_key(key) }
-      end
-
-      def normalized_key(key)
-        key.to_s
-           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-           .downcase
-           .gsub(/[^a-z0-9]+/, "_")
-           .gsub(/_+/, "_")
-           .delete_prefix("_")
-           .delete_suffix("_")
-      end
-
-      def redacted_key_component?(key, candidate)
-        key == candidate ||
-          key.start_with?("#{candidate}_") ||
-          key.end_with?("_#{candidate}") ||
-          key.include?("_#{candidate}_")
-      end
-
-      def value_string(value)
-        case value
-        when Hash, Array
-          JSON.generate(value)
-        else
-          value.to_s
-        end
-      rescue JSON::GeneratorError, TypeError
-        value.to_s
-      end
-
-      def truncate_bytes(string, limit)
-        string.byteslice(0, limit).to_s.encode("UTF-8", invalid: :replace, undef: :replace)
-      end
-
-      def max_tag_count(config)
-        [config.max_tag_count.to_i, 0].max
-      end
-
-      def max_tag_value_bytesize(config)
-        [config.max_tag_value_bytesize.to_i, 0].max
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/tag_sql.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "active_record_adapter"
-require_relative "tag_key"
-
-module LlmCostTracker
-  module TagSql
-    class << self
-      def value_expression(model, key, table_name:)
-        key = TagKey.validate!(key)
-        column = "#{table_name}.#{model.connection.quote_column_name('tags')}"
-
-        if ActiveRecordAdapter.postgresql?(model.connection)
-          json_column = model.tags_jsonb_column? ? column : "(#{column})::jsonb"
-          "#{json_column}->>#{model.connection.quote(key)}"
-        elsif ActiveRecordAdapter.mysql?(model.connection)
-          "JSON_UNQUOTE(JSON_EXTRACT(#{column}, #{model.connection.quote(json_path(key))}))"
-        else
-          "json_extract(#{column}, #{model.connection.quote(json_path(key))})"
-        end
-      end
-
-      def value_label(value)
-        value.nil? || value == "" ? "(untagged)" : value.to_s
-      end
-
-      private
-
-      def json_path(key)
-        "$.\"#{key}\""
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/tags_column.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "active_record_adapter"
-
-module LlmCostTracker
-  module TagsColumn
-    USAGE_BREAKDOWN_COLUMNS = %w[
-      cache_read_input_tokens
-      cache_write_input_tokens
-      hidden_output_tokens
-    ].freeze
-
-    USAGE_BREAKDOWN_COST_COLUMNS = %w[
-      cache_read_input_cost
-      cache_write_input_cost
-    ].freeze
-
-    def reset_column_information
-      remove_instance_variable(:@lct_schema_capabilities) if instance_variable_defined?(:@lct_schema_capabilities)
-
-      super
-    end
-
-    def tags_json_column?
-      capabilities = lct_schema_capabilities
-
-      capabilities.fetch(:tags_jsonb) || capabilities.fetch(:tags_mysql_json)
-    end
-
-    def tags_jsonb_column?
-      lct_schema_capabilities.fetch(:tags_jsonb)
-    end
-
-    def tags_mysql_json_column?
-      lct_schema_capabilities.fetch(:tags_mysql_json)
-    end
-
-    def latency_column?
-      lct_schema_capabilities.fetch(:latency)
-    end
-
-    def stream_column?
-      lct_schema_capabilities.fetch(:stream)
-    end
-
-    def usage_source_column?
-      lct_schema_capabilities.fetch(:usage_source)
-    end
-
-    def provider_response_id_column?
-      lct_schema_capabilities.fetch(:provider_response_id)
-    end
-
-    def pricing_mode_column?
-      lct_schema_capabilities.fetch(:pricing_mode)
-    end
-
-    def usage_breakdown_columns?
-      lct_schema_capabilities.fetch(:usage_breakdown)
-    end
-
-    def usage_breakdown_cost_columns?
-      lct_schema_capabilities.fetch(:usage_breakdown_cost)
-    end
-
-    private
-
-    def lct_schema_capabilities
-      columns = columns_hash
-      adapter_name = connection.adapter_name
-      cache = @lct_schema_capabilities
-
-      return cache.fetch(:values) if cache && cache.fetch(:columns).equal?(columns) &&
-                                     cache.fetch(:adapter_name) == adapter_name
-
-      values = build_lct_schema_capabilities(columns, adapter_name)
-      @lct_schema_capabilities = { columns: columns, adapter_name: adapter_name, values: values }
-      values
-    end
-
-    def build_lct_schema_capabilities(columns, adapter_name)
-      tag_column = columns["tags"]
-      tags_jsonb = tag_column && (tag_column.type == :jsonb || tag_column.sql_type.to_s.downcase == "jsonb")
-      tags_mysql_json =
-        tag_column &&
-        !tags_jsonb &&
-        tag_column.type == :json &&
-        ActiveRecordAdapter.mysql?(adapter_name)
-
-      {
-        tags_jsonb: tags_jsonb ? true : false,
-        tags_mysql_json: tags_mysql_json ? true : false,
-        latency: columns.key?("latency_ms"),
-        stream: columns.key?("stream"),
-        usage_source: columns.key?("usage_source"),
-        provider_response_id: columns.key?("provider_response_id"),
-        pricing_mode: columns.key?("pricing_mode"),
-        usage_breakdown: USAGE_BREAKDOWN_COLUMNS.all? { |column| columns.key?(column) },
-        usage_breakdown_cost: USAGE_BREAKDOWN_COST_COLUMNS.all? { |column| columns.key?(column) }
-      }
-    end
-  end
-end

data/lib/llm_cost_tracker/unknown_pricing.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-require_relative "logging"
-
-module LlmCostTracker
-  class UnknownPricing
-    MUTEX = Monitor.new
-
-    class << self
-      def handle!(model)
-        model = normalized_model_name(model)
-
-        case behavior
-        when :ignore
-          nil
-        when :warn
-          warn_missing(model)
-        when :raise
-          raise UnknownPricingError.new(model: model)
-        end
-      end
-
-      def reset!
-        MUTEX.synchronize { @warned_models = Set.new }
-      end
-
-      private
-
-      def normalized_model_name(model)
-        model.to_s.empty? ? "unknown" : model.to_s
-      end
-
-      def warn_missing(model)
-        should_warn = MUTEX.synchronize do
-          @warned_models ||= Set.new
-          @warned_models.add?(model)
-        end
-        return unless should_warn
-
-        Logging.warn(
-          "No pricing configured for model #{model.inspect}. " \
-          "Cost and budget guardrails will be skipped for this event. " \
-          "Add a pricing_overrides entry or set unknown_pricing_behavior."
-        )
-      end
-
-      def behavior
-        LlmCostTracker.configuration.unknown_pricing_behavior
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/usage_breakdown.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  UsageBreakdown = Data.define(
-    :input_tokens,
-    :cache_read_input_tokens,
-    :cache_write_input_tokens,
-    :output_tokens,
-    :hidden_output_tokens
-  ) do
-    def self.build(input_tokens:, output_tokens:, cache_read_input_tokens: 0,
-                   cache_write_input_tokens: 0, hidden_output_tokens: 0)
-      new(
-        input_tokens: input_tokens.to_i,
-        cache_read_input_tokens: cache_read_input_tokens.to_i,
-        cache_write_input_tokens: cache_write_input_tokens.to_i,
-        output_tokens: output_tokens.to_i,
-        hidden_output_tokens: hidden_output_tokens.to_i
-      )
-    end
-
-    def total_tokens
-      input_tokens + cache_read_input_tokens + cache_write_input_tokens + output_tokens
-    end
-
-    def to_h
-      super.merge(total_tokens: total_tokens).compact
-    end
-  end
-end

data/lib/llm_cost_tracker/value_helpers.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module ValueHelpers
-    class << self
-      def deep_dup(value)
-        case value
-        when Hash
-          value.each_with_object({}) do |(key, nested_value), duplicated|
-            duplicated[deep_dup(key)] = deep_dup(nested_value)
-          end
-        when Array
-          value.map { |nested_value| deep_dup(nested_value) }
-        when String
-          value.dup
-        else
-          value
-        end
-      end
-
-      def deep_freeze(value)
-        case value
-        when Hash
-          value.each do |key, nested_value|
-            deep_freeze(key)
-            deep_freeze(nested_value)
-          end
-          value.frozen? ? value : value.freeze
-        when Array
-          value.each { |nested_value| deep_freeze(nested_value) }
-          value.frozen? ? value : value.freeze
-        when String
-          value.frozen? ? value : value.freeze
-        else
-          value
-        end
-      end
-    end
-  end
-end